1//===-- LLParser.cpp - Parser Class ---------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the parser class for .ll files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LLParser.h"
14#include "LLToken.h"
15#include "llvm/ADT/APSInt.h"
16#include "llvm/ADT/DenseMap.h"
17#include "llvm/ADT/None.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/AsmParser/SlotMapping.h"
21#include "llvm/BinaryFormat/Dwarf.h"
22#include "llvm/IR/Argument.h"
23#include "llvm/IR/AutoUpgrade.h"
24#include "llvm/IR/BasicBlock.h"
25#include "llvm/IR/CallingConv.h"
26#include "llvm/IR/Comdat.h"
27#include "llvm/IR/ConstantRange.h"
28#include "llvm/IR/Constants.h"
29#include "llvm/IR/DebugInfoMetadata.h"
30#include "llvm/IR/DerivedTypes.h"
31#include "llvm/IR/Function.h"
32#include "llvm/IR/GlobalIFunc.h"
33#include "llvm/IR/GlobalObject.h"
34#include "llvm/IR/InlineAsm.h"
35#include "llvm/IR/Intrinsics.h"
36#include "llvm/IR/LLVMContext.h"
37#include "llvm/IR/Metadata.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Value.h"
40#include "llvm/IR/ValueSymbolTable.h"
41#include "llvm/Support/Casting.h"
42#include "llvm/Support/ErrorHandling.h"
43#include "llvm/Support/MathExtras.h"
44#include "llvm/Support/SaveAndRestore.h"
45#include "llvm/Support/raw_ostream.h"
46#include <algorithm>
47#include <cassert>
48#include <cstring>
49#include <iterator>
50#include <vector>
51
52using namespace llvm;
53
54static std::string getTypeString(Type *T) {
55 std::string Result;
56 raw_string_ostream Tmp(Result);
57 Tmp << *T;
58 return Tmp.str();
59}
60
61/// Run: module ::= toplevelentity*
62bool LLParser::Run(bool UpgradeDebugInfo,
63 DataLayoutCallbackTy DataLayoutCallback) {
64 // Prime the lexer.
65 Lex.Lex();
66
67 if (Context.shouldDiscardValueNames())
68 return error(
69 Lex.getLoc(),
70 "Can't read textual IR with a Context that discards named Values");
71
72 if (M) {
73 if (parseTargetDefinitions())
74 return true;
75
76 if (auto LayoutOverride = DataLayoutCallback(M->getTargetTriple()))
77 M->setDataLayout(*LayoutOverride);
78 }
79
80 return parseTopLevelEntities() || validateEndOfModule(UpgradeDebugInfo) ||
81 validateEndOfIndex();
82}
83
84bool LLParser::parseStandaloneConstantValue(Constant *&C,
85 const SlotMapping *Slots) {
86 restoreParsingState(Slots);
87 Lex.Lex();
88
89 Type *Ty = nullptr;
90 if (parseType(Ty) || parseConstantValue(Ty, C))
91 return true;
92 if (Lex.getKind() != lltok::Eof)
93 return error(Lex.getLoc(), "expected end of string");
94 return false;
95}
96
97bool LLParser::parseTypeAtBeginning(Type *&Ty, unsigned &Read,
98 const SlotMapping *Slots) {
99 restoreParsingState(Slots);
100 Lex.Lex();
101
102 Read = 0;
103 SMLoc Start = Lex.getLoc();
104 Ty = nullptr;
105 if (parseType(Ty))
106 return true;
107 SMLoc End = Lex.getLoc();
108 Read = End.getPointer() - Start.getPointer();
109
110 return false;
111}
112
113void LLParser::restoreParsingState(const SlotMapping *Slots) {
114 if (!Slots)
115 return;
116 NumberedVals = Slots->GlobalValues;
117 NumberedMetadata = Slots->MetadataNodes;
118 for (const auto &I : Slots->NamedTypes)
119 NamedTypes.insert(
120 std::make_pair(I.getKey(), std::make_pair(I.second, LocTy())));
121 for (const auto &I : Slots->Types)
122 NumberedTypes.insert(
123 std::make_pair(I.first, std::make_pair(I.second, LocTy())));
124}
125
126/// validateEndOfModule - Do final validity and sanity checks at the end of the
127/// module.
128bool LLParser::validateEndOfModule(bool UpgradeDebugInfo) {
129 if (!M)
130 return false;
131 // Handle any function attribute group forward references.
132 for (const auto &RAG : ForwardRefAttrGroups) {
133 Value *V = RAG.first;
134 const std::vector<unsigned> &Attrs = RAG.second;
135 AttrBuilder B;
136
137 for (const auto &Attr : Attrs)
138 B.merge(NumberedAttrBuilders[Attr]);
139
140 if (Function *Fn = dyn_cast<Function>(V)) {
141 AttributeList AS = Fn->getAttributes();
142 AttrBuilder FnAttrs(AS.getFnAttributes());
143 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
144
145 FnAttrs.merge(B);
146
147 // If the alignment was parsed as an attribute, move to the alignment
148 // field.
149 if (FnAttrs.hasAlignmentAttr()) {
150 Fn->setAlignment(FnAttrs.getAlignment());
151 FnAttrs.removeAttribute(Attribute::Alignment);
152 }
153
154 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
155 AttributeSet::get(Context, FnAttrs));
156 Fn->setAttributes(AS);
157 } else if (CallInst *CI = dyn_cast<CallInst>(V)) {
158 AttributeList AS = CI->getAttributes();
159 AttrBuilder FnAttrs(AS.getFnAttributes());
160 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
161 FnAttrs.merge(B);
162 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
163 AttributeSet::get(Context, FnAttrs));
164 CI->setAttributes(AS);
165 } else if (InvokeInst *II = dyn_cast<InvokeInst>(V)) {
166 AttributeList AS = II->getAttributes();
167 AttrBuilder FnAttrs(AS.getFnAttributes());
168 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
169 FnAttrs.merge(B);
170 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
171 AttributeSet::get(Context, FnAttrs));
172 II->setAttributes(AS);
173 } else if (CallBrInst *CBI = dyn_cast<CallBrInst>(V)) {
174 AttributeList AS = CBI->getAttributes();
175 AttrBuilder FnAttrs(AS.getFnAttributes());
176 AS = AS.removeAttributes(Context, AttributeList::FunctionIndex);
177 FnAttrs.merge(B);
178 AS = AS.addAttributes(Context, AttributeList::FunctionIndex,
179 AttributeSet::get(Context, FnAttrs));
180 CBI->setAttributes(AS);
181 } else if (auto *GV = dyn_cast<GlobalVariable>(V)) {
182 AttrBuilder Attrs(GV->getAttributes());
183 Attrs.merge(B);
184 GV->setAttributes(AttributeSet::get(Context,Attrs));
185 } else {
186 llvm_unreachable("invalid object with forward attribute group reference");
187 }
188 }
189
190 // If there are entries in ForwardRefBlockAddresses at this point, the
191 // function was never defined.
192 if (!ForwardRefBlockAddresses.empty())
193 return error(ForwardRefBlockAddresses.begin()->first.Loc,
194 "expected function name in blockaddress");
195
196 for (const auto &NT : NumberedTypes)
197 if (NT.second.second.isValid())
198 return error(NT.second.second,
199 "use of undefined type '%" + Twine(NT.first) + "'");
200
201 for (StringMap<std::pair<Type*, LocTy> >::iterator I =
202 NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I)
203 if (I->second.second.isValid())
204 return error(I->second.second,
205 "use of undefined type named '" + I->getKey() + "'");
206
207 if (!ForwardRefComdats.empty())
208 return error(ForwardRefComdats.begin()->second,
209 "use of undefined comdat '$" +
210 ForwardRefComdats.begin()->first + "'");
211
212 if (!ForwardRefVals.empty())
213 return error(ForwardRefVals.begin()->second.second,
214 "use of undefined value '@" + ForwardRefVals.begin()->first +
215 "'");
216
217 if (!ForwardRefValIDs.empty())
218 return error(ForwardRefValIDs.begin()->second.second,
219 "use of undefined value '@" +
220 Twine(ForwardRefValIDs.begin()->first) + "'");
221
222 if (!ForwardRefMDNodes.empty())
223 return error(ForwardRefMDNodes.begin()->second.second,
224 "use of undefined metadata '!" +
225 Twine(ForwardRefMDNodes.begin()->first) + "'");
226
227 // Resolve metadata cycles.
228 for (auto &N : NumberedMetadata) {
229 if (N.second && !N.second->isResolved())
230 N.second->resolveCycles();
231 }
232
233 for (auto *Inst : InstsWithTBAATag) {
234 MDNode *MD = Inst->getMetadata(LLVMContext::MD_tbaa);
235 assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
236 auto *UpgradedMD = UpgradeTBAANode(*MD);
237 if (MD != UpgradedMD)
238 Inst->setMetadata(LLVMContext::MD_tbaa, UpgradedMD);
239 }
240
241 // Look for intrinsic functions and CallInst that need to be upgraded
242 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
243 UpgradeCallsToIntrinsic(&*FI++); // must be post-increment, as we remove
244
245 // Some types could be renamed during loading if several modules are
246 // loaded in the same LLVMContext (LTO scenario). In this case we should
247 // remangle intrinsics names as well.
248 for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) {
249 Function *F = &*FI++;
250 if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) {
251 F->replaceAllUsesWith(Remangled.getValue());
252 F->eraseFromParent();
253 }
254 }
255
256 if (UpgradeDebugInfo)
257 llvm::UpgradeDebugInfo(*M);
258
259 UpgradeModuleFlags(*M);
260 UpgradeSectionAttributes(*M);
261
262 if (!Slots)
263 return false;
264 // Initialize the slot mapping.
265 // Because by this point we've parsed and validated everything, we can "steal"
266 // the mapping from LLParser as it doesn't need it anymore.
267 Slots->GlobalValues = std::move(NumberedVals);
268 Slots->MetadataNodes = std::move(NumberedMetadata);
269 for (const auto &I : NamedTypes)
270 Slots->NamedTypes.insert(std::make_pair(I.getKey(), I.second.first));
271 for (const auto &I : NumberedTypes)
272 Slots->Types.insert(std::make_pair(I.first, I.second.first));
273
274 return false;
275}
276
277/// Do final validity and sanity checks at the end of the index.
278bool LLParser::validateEndOfIndex() {
279 if (!Index)
280 return false;
281
282 if (!ForwardRefValueInfos.empty())
283 return error(ForwardRefValueInfos.begin()->second.front().second,
284 "use of undefined summary '^" +
285 Twine(ForwardRefValueInfos.begin()->first) + "'");
286
287 if (!ForwardRefAliasees.empty())
288 return error(ForwardRefAliasees.begin()->second.front().second,
289 "use of undefined summary '^" +
290 Twine(ForwardRefAliasees.begin()->first) + "'");
291
292 if (!ForwardRefTypeIds.empty())
293 return error(ForwardRefTypeIds.begin()->second.front().second,
294 "use of undefined type id summary '^" +
295 Twine(ForwardRefTypeIds.begin()->first) + "'");
296
297 return false;
298}
299
300//===----------------------------------------------------------------------===//
301// Top-Level Entities
302//===----------------------------------------------------------------------===//
303
304bool LLParser::parseTargetDefinitions() {
305 while (true) {
306 switch (Lex.getKind()) {
307 case lltok::kw_target:
308 if (parseTargetDefinition())
309 return true;
310 break;
311 case lltok::kw_source_filename:
312 if (parseSourceFileName())
313 return true;
314 break;
315 default:
316 return false;
317 }
318 }
319}
320
321bool LLParser::parseTopLevelEntities() {
322 // If there is no Module, then parse just the summary index entries.
323 if (!M) {
324 while (true) {
325 switch (Lex.getKind()) {
326 case lltok::Eof:
327 return false;
328 case lltok::SummaryID:
329 if (parseSummaryEntry())
330 return true;
331 break;
332 case lltok::kw_source_filename:
333 if (parseSourceFileName())
334 return true;
335 break;
336 default:
337 // Skip everything else
338 Lex.Lex();
339 }
340 }
341 }
342 while (true) {
343 switch (Lex.getKind()) {
344 default:
345 return tokError("expected top-level entity");
346 case lltok::Eof: return false;
347 case lltok::kw_declare:
348 if (parseDeclare())
349 return true;
350 break;
351 case lltok::kw_define:
352 if (parseDefine())
353 return true;
354 break;
355 case lltok::kw_module:
356 if (parseModuleAsm())
357 return true;
358 break;
359 case lltok::kw_deplibs:
360 if (parseDepLibs())
361 return true;
362 break;
363 case lltok::LocalVarID:
364 if (parseUnnamedType())
365 return true;
366 break;
367 case lltok::LocalVar:
368 if (parseNamedType())
369 return true;
370 break;
371 case lltok::GlobalID:
372 if (parseUnnamedGlobal())
373 return true;
374 break;
375 case lltok::GlobalVar:
376 if (parseNamedGlobal())
377 return true;
378 break;
379 case lltok::ComdatVar: if (parseComdat()) return true; break;
380 case lltok::exclaim:
381 if (parseStandaloneMetadata())
382 return true;
383 break;
384 case lltok::SummaryID:
385 if (parseSummaryEntry())
386 return true;
387 break;
388 case lltok::MetadataVar:
389 if (parseNamedMetadata())
390 return true;
391 break;
392 case lltok::kw_attributes:
393 if (parseUnnamedAttrGrp())
394 return true;
395 break;
396 case lltok::kw_uselistorder:
397 if (parseUseListOrder())
398 return true;
399 break;
400 case lltok::kw_uselistorder_bb:
401 if (parseUseListOrderBB())
402 return true;
403 break;
404 }
405 }
406}
407
408/// toplevelentity
409/// ::= 'module' 'asm' STRINGCONSTANT
410bool LLParser::parseModuleAsm() {
411 assert(Lex.getKind() == lltok::kw_module);
412 Lex.Lex();
413
414 std::string AsmStr;
415 if (parseToken(lltok::kw_asm, "expected 'module asm'") ||
416 parseStringConstant(AsmStr))
417 return true;
418
419 M->appendModuleInlineAsm(AsmStr);
420 return false;
421}
422
423/// toplevelentity
424/// ::= 'target' 'triple' '=' STRINGCONSTANT
425/// ::= 'target' 'datalayout' '=' STRINGCONSTANT
426bool LLParser::parseTargetDefinition() {
427 assert(Lex.getKind() == lltok::kw_target);
428 std::string Str;
429 switch (Lex.Lex()) {
430 default:
431 return tokError("unknown target property");
432 case lltok::kw_triple:
433 Lex.Lex();
434 if (parseToken(lltok::equal, "expected '=' after target triple") ||
435 parseStringConstant(Str))
436 return true;
437 M->setTargetTriple(Str);
438 return false;
439 case lltok::kw_datalayout:
440 Lex.Lex();
441 if (parseToken(lltok::equal, "expected '=' after target datalayout") ||
442 parseStringConstant(Str))
443 return true;
444 M->setDataLayout(Str);
445 return false;
446 }
447}
448
449/// toplevelentity
450/// ::= 'source_filename' '=' STRINGCONSTANT
451bool LLParser::parseSourceFileName() {
452 assert(Lex.getKind() == lltok::kw_source_filename);
453 Lex.Lex();
454 if (parseToken(lltok::equal, "expected '=' after source_filename") ||
455 parseStringConstant(SourceFileName))
456 return true;
457 if (M)
458 M->setSourceFileName(SourceFileName);
459 return false;
460}
461
462/// toplevelentity
463/// ::= 'deplibs' '=' '[' ']'
464/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
465/// FIXME: Remove in 4.0. Currently parse, but ignore.
466bool LLParser::parseDepLibs() {
467 assert(Lex.getKind() == lltok::kw_deplibs);
468 Lex.Lex();
469 if (parseToken(lltok::equal, "expected '=' after deplibs") ||
470 parseToken(lltok::lsquare, "expected '=' after deplibs"))
471 return true;
472
473 if (EatIfPresent(lltok::rsquare))
474 return false;
475
476 do {
477 std::string Str;
478 if (parseStringConstant(Str))
479 return true;
480 } while (EatIfPresent(lltok::comma));
481
482 return parseToken(lltok::rsquare, "expected ']' at end of list");
483}
484
485/// parseUnnamedType:
486/// ::= LocalVarID '=' 'type' type
487bool LLParser::parseUnnamedType() {
488 LocTy TypeLoc = Lex.getLoc();
489 unsigned TypeID = Lex.getUIntVal();
490 Lex.Lex(); // eat LocalVarID;
491
492 if (parseToken(lltok::equal, "expected '=' after name") ||
493 parseToken(lltok::kw_type, "expected 'type' after '='"))
494 return true;
495
496 Type *Result = nullptr;
497 if (parseStructDefinition(TypeLoc, "", NumberedTypes[TypeID], Result))
498 return true;
499
500 if (!isa<StructType>(Result)) {
501 std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
502 if (Entry.first)
503 return error(TypeLoc, "non-struct types may not be recursive");
504 Entry.first = Result;
505 Entry.second = SMLoc();
506 }
507
508 return false;
509}
510
511/// toplevelentity
512/// ::= LocalVar '=' 'type' type
513bool LLParser::parseNamedType() {
514 std::string Name = Lex.getStrVal();
515 LocTy NameLoc = Lex.getLoc();
516 Lex.Lex(); // eat LocalVar.
517
518 if (parseToken(lltok::equal, "expected '=' after name") ||
519 parseToken(lltok::kw_type, "expected 'type' after name"))
520 return true;
521
522 Type *Result = nullptr;
523 if (parseStructDefinition(NameLoc, Name, NamedTypes[Name], Result))
524 return true;
525
526 if (!isa<StructType>(Result)) {
527 std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
528 if (Entry.first)
529 return error(NameLoc, "non-struct types may not be recursive");
530 Entry.first = Result;
531 Entry.second = SMLoc();
532 }
533
534 return false;
535}
536
537/// toplevelentity
538/// ::= 'declare' FunctionHeader
539bool LLParser::parseDeclare() {
540 assert(Lex.getKind() == lltok::kw_declare);
541 Lex.Lex();
542
543 std::vector<std::pair<unsigned, MDNode *>> MDs;
544 while (Lex.getKind() == lltok::MetadataVar) {
545 unsigned MDK;
546 MDNode *N;
547 if (parseMetadataAttachment(MDK, N))
548 return true;
549 MDs.push_back({MDK, N});
550 }
551
552 Function *F;
553 if (parseFunctionHeader(F, false))
554 return true;
555 for (auto &MD : MDs)
556 F->addMetadata(MD.first, *MD.second);
557 return false;
558}
559
560/// toplevelentity
561/// ::= 'define' FunctionHeader (!dbg !56)* '{' ...
562bool LLParser::parseDefine() {
563 assert(Lex.getKind() == lltok::kw_define);
564 Lex.Lex();
565
566 Function *F;
567 return parseFunctionHeader(F, true) || parseOptionalFunctionMetadata(*F) ||
568 parseFunctionBody(*F);
569}
570
571/// parseGlobalType
572/// ::= 'constant'
573/// ::= 'global'
574bool LLParser::parseGlobalType(bool &IsConstant) {
575 if (Lex.getKind() == lltok::kw_constant)
576 IsConstant = true;
577 else if (Lex.getKind() == lltok::kw_global)
578 IsConstant = false;
579 else {
580 IsConstant = false;
581 return tokError("expected 'global' or 'constant'");
582 }
583 Lex.Lex();
584 return false;
585}
586
587bool LLParser::parseOptionalUnnamedAddr(
588 GlobalVariable::UnnamedAddr &UnnamedAddr) {
589 if (EatIfPresent(lltok::kw_unnamed_addr))
590 UnnamedAddr = GlobalValue::UnnamedAddr::Global;
591 else if (EatIfPresent(lltok::kw_local_unnamed_addr))
592 UnnamedAddr = GlobalValue::UnnamedAddr::Local;
593 else
594 UnnamedAddr = GlobalValue::UnnamedAddr::None;
595 return false;
596}
597
598/// parseUnnamedGlobal:
599/// OptionalVisibility (ALIAS | IFUNC) ...
600/// OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
601/// OptionalDLLStorageClass
602/// ... -> global variable
603/// GlobalID '=' OptionalVisibility (ALIAS | IFUNC) ...
604/// GlobalID '=' OptionalLinkage OptionalPreemptionSpecifier
605/// OptionalVisibility
606/// OptionalDLLStorageClass
607/// ... -> global variable
608bool LLParser::parseUnnamedGlobal() {
609 unsigned VarID = NumberedVals.size();
610 std::string Name;
611 LocTy NameLoc = Lex.getLoc();
612
613 // Handle the GlobalID form.
614 if (Lex.getKind() == lltok::GlobalID) {
615 if (Lex.getUIntVal() != VarID)
616 return error(Lex.getLoc(),
617 "variable expected to be numbered '%" + Twine(VarID) + "'");
618 Lex.Lex(); // eat GlobalID;
619
620 if (parseToken(lltok::equal, "expected '=' after name"))
621 return true;
622 }
623
624 bool HasLinkage;
625 unsigned Linkage, Visibility, DLLStorageClass;
626 bool DSOLocal;
627 GlobalVariable::ThreadLocalMode TLM;
628 GlobalVariable::UnnamedAddr UnnamedAddr;
629 if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
630 DSOLocal) ||
631 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
632 return true;
633
634 if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
635 return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
636 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
637
638 return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
639 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
640}
641
642/// parseNamedGlobal:
643/// GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
644/// GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
645/// OptionalVisibility OptionalDLLStorageClass
646/// ... -> global variable
647bool LLParser::parseNamedGlobal() {
648 assert(Lex.getKind() == lltok::GlobalVar);
649 LocTy NameLoc = Lex.getLoc();
650 std::string Name = Lex.getStrVal();
651 Lex.Lex();
652
653 bool HasLinkage;
654 unsigned Linkage, Visibility, DLLStorageClass;
655 bool DSOLocal;
656 GlobalVariable::ThreadLocalMode TLM;
657 GlobalVariable::UnnamedAddr UnnamedAddr;
658 if (parseToken(lltok::equal, "expected '=' in global variable") ||
659 parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
660 DSOLocal) ||
661 parseOptionalThreadLocal(TLM) || parseOptionalUnnamedAddr(UnnamedAddr))
662 return true;
663
664 if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
665 return parseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
666 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
667
668 return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
669 DLLStorageClass, DSOLocal, TLM, UnnamedAddr);
670}
671
672bool LLParser::parseComdat() {
673 assert(Lex.getKind() == lltok::ComdatVar);
674 std::string Name = Lex.getStrVal();
675 LocTy NameLoc = Lex.getLoc();
676 Lex.Lex();
677
678 if (parseToken(lltok::equal, "expected '=' here"))
679 return true;
680
681 if (parseToken(lltok::kw_comdat, "expected comdat keyword"))
682 return tokError("expected comdat type");
683
684 Comdat::SelectionKind SK;
685 switch (Lex.getKind()) {
686 default:
687 return tokError("unknown selection kind");
688 case lltok::kw_any:
689 SK = Comdat::Any;
690 break;
691 case lltok::kw_exactmatch:
692 SK = Comdat::ExactMatch;
693 break;
694 case lltok::kw_largest:
695 SK = Comdat::Largest;
696 break;
697 case lltok::kw_noduplicates:
698 SK = Comdat::NoDuplicates;
699 break;
700 case lltok::kw_samesize:
701 SK = Comdat::SameSize;
702 break;
703 }
704 Lex.Lex();
705
706 // See if the comdat was forward referenced, if so, use the comdat.
707 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
708 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
709 if (I != ComdatSymTab.end() && !ForwardRefComdats.erase(Name))
710 return error(NameLoc, "redefinition of comdat '$" + Name + "'");
711
712 Comdat *C;
713 if (I != ComdatSymTab.end())
714 C = &I->second;
715 else
716 C = M->getOrInsertComdat(Name);
717 C->setSelectionKind(SK);
718
719 return false;
720}
721
722// MDString:
723// ::= '!' STRINGCONSTANT
724bool LLParser::parseMDString(MDString *&Result) {
725 std::string Str;
726 if (parseStringConstant(Str))
727 return true;
728 Result = MDString::get(Context, Str);
729 return false;
730}
731
732// MDNode:
733// ::= '!' MDNodeNumber
734bool LLParser::parseMDNodeID(MDNode *&Result) {
735 // !{ ..., !42, ... }
736 LocTy IDLoc = Lex.getLoc();
737 unsigned MID = 0;
738 if (parseUInt32(MID))
739 return true;
740
741 // If not a forward reference, just return it now.
742 if (NumberedMetadata.count(MID)) {
743 Result = NumberedMetadata[MID];
744 return false;
745 }
746
747 // Otherwise, create MDNode forward reference.
748 auto &FwdRef = ForwardRefMDNodes[MID];
749 FwdRef = std::make_pair(MDTuple::getTemporary(Context, None), IDLoc);
750
751 Result = FwdRef.first.get();
752 NumberedMetadata[MID].reset(Result);
753 return false;
754}
755
756/// parseNamedMetadata:
757/// !foo = !{ !1, !2 }
758bool LLParser::parseNamedMetadata() {
759 assert(Lex.getKind() == lltok::MetadataVar);
760 std::string Name = Lex.getStrVal();
761 Lex.Lex();
762
763 if (parseToken(lltok::equal, "expected '=' here") ||
764 parseToken(lltok::exclaim, "Expected '!' here") ||
765 parseToken(lltok::lbrace, "Expected '{' here"))
766 return true;
767
768 NamedMDNode *NMD = M->getOrInsertNamedMetadata(Name);
769 if (Lex.getKind() != lltok::rbrace)
770 do {
771 MDNode *N = nullptr;
772 // parse DIExpressions inline as a special case. They are still MDNodes,
773 // so they can still appear in named metadata. Remove this logic if they
774 // become plain Metadata.
775 if (Lex.getKind() == lltok::MetadataVar &&
776 Lex.getStrVal() == "DIExpression") {
777 if (parseDIExpression(N, /*IsDistinct=*/false))
778 return true;
779 } else if (parseToken(lltok::exclaim, "Expected '!' here") ||
780 parseMDNodeID(N)) {
781 return true;
782 }
783 NMD->addOperand(N);
784 } while (EatIfPresent(lltok::comma));
785
786 return parseToken(lltok::rbrace, "expected end of metadata node");
787}
788
789/// parseStandaloneMetadata:
790/// !42 = !{...}
791bool LLParser::parseStandaloneMetadata() {
792 assert(Lex.getKind() == lltok::exclaim);
793 Lex.Lex();
794 unsigned MetadataID = 0;
795
796 MDNode *Init;
797 if (parseUInt32(MetadataID) || parseToken(lltok::equal, "expected '=' here"))
798 return true;
799
800 // Detect common error, from old metadata syntax.
801 if (Lex.getKind() == lltok::Type)
802 return tokError("unexpected type in metadata definition");
803
804 bool IsDistinct = EatIfPresent(lltok::kw_distinct);
805 if (Lex.getKind() == lltok::MetadataVar) {
806 if (parseSpecializedMDNode(Init, IsDistinct))
807 return true;
808 } else if (parseToken(lltok::exclaim, "Expected '!' here") ||
809 parseMDTuple(Init, IsDistinct))
810 return true;
811
812 // See if this was forward referenced, if so, handle it.
813 auto FI = ForwardRefMDNodes.find(MetadataID);
814 if (FI != ForwardRefMDNodes.end()) {
815 FI->second.first->replaceAllUsesWith(Init);
816 ForwardRefMDNodes.erase(FI);
817
818 assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work");
819 } else {
820 if (NumberedMetadata.count(MetadataID))
821 return tokError("Metadata id is already used");
822 NumberedMetadata[MetadataID].reset(Init);
823 }
824
825 return false;
826}
827
828// Skips a single module summary entry.
829bool LLParser::skipModuleSummaryEntry() {
830 // Each module summary entry consists of a tag for the entry
831 // type, followed by a colon, then the fields which may be surrounded by
832 // nested sets of parentheses. The "tag:" looks like a Label. Once parsing
833 // support is in place we will look for the tokens corresponding to the
834 // expected tags.
835 if (Lex.getKind() != lltok::kw_gv && Lex.getKind() != lltok::kw_module &&
836 Lex.getKind() != lltok::kw_typeid && Lex.getKind() != lltok::kw_flags &&
837 Lex.getKind() != lltok::kw_blockcount)
838 return tokError(
839 "Expected 'gv', 'module', 'typeid', 'flags' or 'blockcount' at the "
840 "start of summary entry");
841 if (Lex.getKind() == lltok::kw_flags)
842 return parseSummaryIndexFlags();
843 if (Lex.getKind() == lltok::kw_blockcount)
844 return parseBlockCount();
845 Lex.Lex();
846 if (parseToken(lltok::colon, "expected ':' at start of summary entry") ||
847 parseToken(lltok::lparen, "expected '(' at start of summary entry"))
848 return true;
849 // Now walk through the parenthesized entry, until the number of open
850 // parentheses goes back down to 0 (the first '(' was parsed above).
851 unsigned NumOpenParen = 1;
852 do {
853 switch (Lex.getKind()) {
854 case lltok::lparen:
855 NumOpenParen++;
856 break;
857 case lltok::rparen:
858 NumOpenParen--;
859 break;
860 case lltok::Eof:
861 return tokError("found end of file while parsing summary entry");
862 default:
863 // Skip everything in between parentheses.
864 break;
865 }
866 Lex.Lex();
867 } while (NumOpenParen > 0);
868 return false;
869}
870
871/// SummaryEntry
872/// ::= SummaryID '=' GVEntry | ModuleEntry | TypeIdEntry
873bool LLParser::parseSummaryEntry() {
874 assert(Lex.getKind() == lltok::SummaryID);
875 unsigned SummaryID = Lex.getUIntVal();
876
877 // For summary entries, colons should be treated as distinct tokens,
878 // not an indication of the end of a label token.
879 Lex.setIgnoreColonInIdentifiers(true);
880
881 Lex.Lex();
882 if (parseToken(lltok::equal, "expected '=' here"))
883 return true;
884
885 // If we don't have an index object, skip the summary entry.
886 if (!Index)
887 return skipModuleSummaryEntry();
888
889 bool result = false;
890 switch (Lex.getKind()) {
891 case lltok::kw_gv:
892 result = parseGVEntry(SummaryID);
893 break;
894 case lltok::kw_module:
895 result = parseModuleEntry(SummaryID);
896 break;
897 case lltok::kw_typeid:
898 result = parseTypeIdEntry(SummaryID);
899 break;
900 case lltok::kw_typeidCompatibleVTable:
901 result = parseTypeIdCompatibleVtableEntry(SummaryID);
902 break;
903 case lltok::kw_flags:
904 result = parseSummaryIndexFlags();
905 break;
906 case lltok::kw_blockcount:
907 result = parseBlockCount();
908 break;
909 default:
910 result = error(Lex.getLoc(), "unexpected summary kind");
911 break;
912 }
913 Lex.setIgnoreColonInIdentifiers(false);
914 return result;
915}
916
917static bool isValidVisibilityForLinkage(unsigned V, unsigned L) {
918 return !GlobalValue::isLocalLinkage((GlobalValue::LinkageTypes)L) ||
919 (GlobalValue::VisibilityTypes)V == GlobalValue::DefaultVisibility;
920}
921
922// If there was an explicit dso_local, update GV. In the absence of an explicit
923// dso_local we keep the default value.
924static void maybeSetDSOLocal(bool DSOLocal, GlobalValue &GV) {
925 if (DSOLocal)
926 GV.setDSOLocal(true);
927}
928
929/// parseIndirectSymbol:
930/// ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
931/// OptionalVisibility OptionalDLLStorageClass
932/// OptionalThreadLocal OptionalUnnamedAddr
933/// 'alias|ifunc' IndirectSymbol IndirectSymbolAttr*
934///
935/// IndirectSymbol
936/// ::= TypeAndValue
937///
938/// IndirectSymbolAttr
939/// ::= ',' 'partition' StringConstant
940///
941/// Everything through OptionalUnnamedAddr has already been parsed.
942///
943bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
944 unsigned L, unsigned Visibility,
945 unsigned DLLStorageClass, bool DSOLocal,
946 GlobalVariable::ThreadLocalMode TLM,
947 GlobalVariable::UnnamedAddr UnnamedAddr) {
948 bool IsAlias;
949 if (Lex.getKind() == lltok::kw_alias)
950 IsAlias = true;
951 else if (Lex.getKind() == lltok::kw_ifunc)
952 IsAlias = false;
953 else
954 llvm_unreachable("Not an alias or ifunc!");
955 Lex.Lex();
956
957 GlobalValue::LinkageTypes Linkage = (GlobalValue::LinkageTypes) L;
958
959 if(IsAlias && !GlobalAlias::isValidLinkage(Linkage))
960 return error(NameLoc, "invalid linkage type for alias");
961
962 if (!isValidVisibilityForLinkage(Visibility, L))
963 return error(NameLoc,
964 "symbol with local linkage must have default visibility");
965
966 Type *Ty;
967 LocTy ExplicitTypeLoc = Lex.getLoc();
968 if (parseType(Ty) ||
969 parseToken(lltok::comma, "expected comma after alias or ifunc's type"))
970 return true;
971
972 Constant *Aliasee;
973 LocTy AliaseeLoc = Lex.getLoc();
974 if (Lex.getKind() != lltok::kw_bitcast &&
975 Lex.getKind() != lltok::kw_getelementptr &&
976 Lex.getKind() != lltok::kw_addrspacecast &&
977 Lex.getKind() != lltok::kw_inttoptr) {
978 if (parseGlobalTypeAndValue(Aliasee))
979 return true;
980 } else {
981 // The bitcast dest type is not present, it is implied by the dest type.
982 ValID ID;
983 if (parseValID(ID))
984 return true;
985 if (ID.Kind != ValID::t_Constant)
986 return error(AliaseeLoc, "invalid aliasee");
987 Aliasee = ID.ConstantVal;
988 }
989
990 Type *AliaseeType = Aliasee->getType();
991 auto *PTy = dyn_cast<PointerType>(AliaseeType);
992 if (!PTy)
993 return error(AliaseeLoc, "An alias or ifunc must have pointer type");
994 unsigned AddrSpace = PTy->getAddressSpace();
995
996 if (IsAlias && Ty != PTy->getElementType())
997 return error(ExplicitTypeLoc,
998 "explicit pointee type doesn't match operand's pointee type");
999
1000 if (!IsAlias && !PTy->getElementType()->isFunctionTy())
1001 return error(ExplicitTypeLoc,
1002 "explicit pointee type should be a function type");
1003
1004 GlobalValue *GVal = nullptr;
1005
1006 // See if the alias was forward referenced, if so, prepare to replace the
1007 // forward reference.
1008 if (!Name.empty()) {
1009 GVal = M->getNamedValue(Name);
1010 if (GVal) {
1011 if (!ForwardRefVals.erase(Name))
1012 return error(NameLoc, "redefinition of global '@" + Name + "'");
1013 }
1014 } else {
1015 auto I = ForwardRefValIDs.find(NumberedVals.size());
1016 if (I != ForwardRefValIDs.end()) {
1017 GVal = I->second.first;
1018 ForwardRefValIDs.erase(I);
1019 }
1020 }
1021
1022 // Okay, create the alias but do not insert it into the module yet.
1023 std::unique_ptr<GlobalIndirectSymbol> GA;
1024 if (IsAlias)
1025 GA.reset(GlobalAlias::create(Ty, AddrSpace,
1026 (GlobalValue::LinkageTypes)Linkage, Name,
1027 Aliasee, /*Parent*/ nullptr));
1028 else
1029 GA.reset(GlobalIFunc::create(Ty, AddrSpace,
1030 (GlobalValue::LinkageTypes)Linkage, Name,
1031 Aliasee, /*Parent*/ nullptr));
1032 GA->setThreadLocalMode(TLM);
1033 GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
1034 GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
1035 GA->setUnnamedAddr(UnnamedAddr);
1036 maybeSetDSOLocal(DSOLocal, *GA);
1037
1038 // At this point we've parsed everything except for the IndirectSymbolAttrs.
1039 // Now parse them if there are any.
1040 while (Lex.getKind() == lltok::comma) {
1041 Lex.Lex();
1042
1043 if (Lex.getKind() == lltok::kw_partition) {
1044 Lex.Lex();
1045 GA->setPartition(Lex.getStrVal());
1046 if (parseToken(lltok::StringConstant, "expected partition string"))
1047 return true;
1048 } else {
1049 return tokError("unknown alias or ifunc property!");
1050 }
1051 }
1052
1053 if (Name.empty())
1054 NumberedVals.push_back(GA.get());
1055
1056 if (GVal) {
1057 // Verify that types agree.
1058 if (GVal->getType() != GA->getType())
1059 return error(
1060 ExplicitTypeLoc,
1061 "forward reference and definition of alias have different types");
1062
1063 // If they agree, just RAUW the old value with the alias and remove the
1064 // forward ref info.
1065 GVal->replaceAllUsesWith(GA.get());
1066 GVal->eraseFromParent();
1067 }
1068
1069 // Insert into the module, we know its name won't collide now.
1070 if (IsAlias)
1071 M->getAliasList().push_back(cast<GlobalAlias>(GA.get()));
1072 else
1073 M->getIFuncList().push_back(cast<GlobalIFunc>(GA.get()));
1074 assert(GA->getName() == Name && "Should not be a name conflict!");
1075
1076 // The module owns this now
1077 GA.release();
1078
1079 return false;
1080}
1081
1082/// parseGlobal
1083/// ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
1084/// OptionalVisibility OptionalDLLStorageClass
1085/// OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
1086/// OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
1087/// ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
1088/// OptionalDLLStorageClass OptionalThreadLocal OptionalUnnamedAddr
1089/// OptionalAddrSpace OptionalExternallyInitialized GlobalType Type
1090/// Const OptionalAttrs
1091///
1092/// Everything up to and including OptionalUnnamedAddr has been parsed
1093/// already.
1094///
1095bool LLParser::parseGlobal(const std::string &Name, LocTy NameLoc,
1096 unsigned Linkage, bool HasLinkage,
1097 unsigned Visibility, unsigned DLLStorageClass,
1098 bool DSOLocal, GlobalVariable::ThreadLocalMode TLM,
1099 GlobalVariable::UnnamedAddr UnnamedAddr) {
1100 if (!isValidVisibilityForLinkage(Visibility, Linkage))
1101 return error(NameLoc,
1102 "symbol with local linkage must have default visibility");
1103
1104 unsigned AddrSpace;
1105 bool IsConstant, IsExternallyInitialized;
1106 LocTy IsExternallyInitializedLoc;
1107 LocTy TyLoc;
1108
1109 Type *Ty = nullptr;
1110 if (parseOptionalAddrSpace(AddrSpace) ||
1111 parseOptionalToken(lltok::kw_externally_initialized,
1112 IsExternallyInitialized,
1113 &IsExternallyInitializedLoc) ||
1114 parseGlobalType(IsConstant) || parseType(Ty, TyLoc))
1115 return true;
1116
1117 // If the linkage is specified and is external, then no initializer is
1118 // present.
1119 Constant *Init = nullptr;
1120 if (!HasLinkage ||
1121 !GlobalValue::isValidDeclarationLinkage(
1122 (GlobalValue::LinkageTypes)Linkage)) {
1123 if (parseGlobalValue(Ty, Init))
1124 return true;
1125 }
1126
1127 if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
1128 return error(TyLoc, "invalid type for global variable");
1129
1130 GlobalValue *GVal = nullptr;
1131
1132 // See if the global was forward referenced, if so, use the global.
1133 if (!Name.empty()) {
1134 GVal = M->getNamedValue(Name);
1135 if (GVal) {
1136 if (!ForwardRefVals.erase(Name))
1137 return error(NameLoc, "redefinition of global '@" + Name + "'");
1138 }
1139 } else {
1140 auto I = ForwardRefValIDs.find(NumberedVals.size());
1141 if (I != ForwardRefValIDs.end()) {
1142 GVal = I->second.first;
1143 ForwardRefValIDs.erase(I);
1144 }
1145 }
1146
1147 GlobalVariable *GV;
1148 if (!GVal) {
1149 GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, nullptr,
1150 Name, nullptr, GlobalVariable::NotThreadLocal,
1151 AddrSpace);
1152 } else {
1153 if (GVal->getValueType() != Ty)
1154 return error(
1155 TyLoc,
1156 "forward reference and definition of global have different types");
1157
1158 GV = cast<GlobalVariable>(GVal);
1159
1160 // Move the forward-reference to the correct spot in the module.
1161 M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
1162 }
1163
1164 if (Name.empty())
1165 NumberedVals.push_back(GV);
1166
1167 // Set the parsed properties on the global.
1168 if (Init)
1169 GV->setInitializer(Init);
1170 GV->setConstant(IsConstant);
1171 GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
1172 maybeSetDSOLocal(DSOLocal, *GV);
1173 GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
1174 GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
1175 GV->setExternallyInitialized(IsExternallyInitialized);
1176 GV->setThreadLocalMode(TLM);
1177 GV->setUnnamedAddr(UnnamedAddr);
1178
1179 // parse attributes on the global.
1180 while (Lex.getKind() == lltok::comma) {
1181 Lex.Lex();
1182
1183 if (Lex.getKind() == lltok::kw_section) {
1184 Lex.Lex();
1185 GV->setSection(Lex.getStrVal());
1186 if (parseToken(lltok::StringConstant, "expected global section string"))
1187 return true;
1188 } else if (Lex.getKind() == lltok::kw_partition) {
1189 Lex.Lex();
1190 GV->setPartition(Lex.getStrVal());
1191 if (parseToken(lltok::StringConstant, "expected partition string"))
1192 return true;
1193 } else if (Lex.getKind() == lltok::kw_align) {
1194 MaybeAlign Alignment;
1195 if (parseOptionalAlignment(Alignment))
1196 return true;
1197 GV->setAlignment(Alignment);
1198 } else if (Lex.getKind() == lltok::MetadataVar) {
1199 if (parseGlobalObjectMetadataAttachment(*GV))
1200 return true;
1201 } else {
1202 Comdat *C;
1203 if (parseOptionalComdat(Name, C))
1204 return true;
1205 if (C)
1206 GV->setComdat(C);
1207 else
1208 return tokError("unknown global variable property!");
1209 }
1210 }
1211
1212 AttrBuilder Attrs;
1213 LocTy BuiltinLoc;
1214 std::vector<unsigned> FwdRefAttrGrps;
1215 if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc))
1216 return true;
1217 if (Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
1218 GV->setAttributes(AttributeSet::get(Context, Attrs));
1219 ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
1220 }
1221
1222 return false;
1223}
1224
1225/// parseUnnamedAttrGrp
1226/// ::= 'attributes' AttrGrpID '=' '{' AttrValPair+ '}'
1227bool LLParser::parseUnnamedAttrGrp() {
1228 assert(Lex.getKind() == lltok::kw_attributes);
1229 LocTy AttrGrpLoc = Lex.getLoc();
1230 Lex.Lex();
1231
1232 if (Lex.getKind() != lltok::AttrGrpID)
1233 return tokError("expected attribute group id");
1234
1235 unsigned VarID = Lex.getUIntVal();
1236 std::vector<unsigned> unused;
1237 LocTy BuiltinLoc;
1238 Lex.Lex();
1239
1240 if (parseToken(lltok::equal, "expected '=' here") ||
1241 parseToken(lltok::lbrace, "expected '{' here") ||
1242 parseFnAttributeValuePairs(NumberedAttrBuilders[VarID], unused, true,
1243 BuiltinLoc) ||
1244 parseToken(lltok::rbrace, "expected end of attribute group"))
1245 return true;
1246
1247 if (!NumberedAttrBuilders[VarID].hasAttributes())
1248 return error(AttrGrpLoc, "attribute group has no attributes");
1249
1250 return false;
1251}
1252
1253/// parseFnAttributeValuePairs
1254/// ::= <attr> | <attr> '=' <value>
1255bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B,
1256 std::vector<unsigned> &FwdRefAttrGrps,
1257 bool inAttrGrp, LocTy &BuiltinLoc) {
1258 bool HaveError = false;
1259
1260 B.clear();
1261
1262 while (true) {
1263 lltok::Kind Token = Lex.getKind();
1264 if (Token == lltok::kw_builtin)
1265 BuiltinLoc = Lex.getLoc();
1266 switch (Token) {
1267 default:
1268 if (!inAttrGrp) return HaveError;
1269 return error(Lex.getLoc(), "unterminated attribute group");
1270 case lltok::rbrace:
1271 // Finished.
1272 return false;
1273
1274 case lltok::AttrGrpID: {
1275 // Allow a function to reference an attribute group:
1276 //
1277 // define void @foo() #1 { ... }
1278 if (inAttrGrp)
1279 HaveError |= error(
1280 Lex.getLoc(),
1281 "cannot have an attribute group reference in an attribute group");
1282
1283 unsigned AttrGrpNum = Lex.getUIntVal();
1284 if (inAttrGrp) break;
1285
1286 // Save the reference to the attribute group. We'll fill it in later.
1287 FwdRefAttrGrps.push_back(AttrGrpNum);
1288 break;
1289 }
1290 // Target-dependent attributes:
1291 case lltok::StringConstant: {
1292 if (parseStringAttribute(B))
1293 return true;
1294 continue;
1295 }
1296
1297 // Target-independent attributes:
1298 case lltok::kw_align: {
1299 // As a hack, we allow function alignment to be initially parsed as an
1300 // attribute on a function declaration/definition or added to an attribute
1301 // group and later moved to the alignment field.
1302 MaybeAlign Alignment;
1303 if (inAttrGrp) {
1304 Lex.Lex();
1305 uint32_t Value = 0;
1306 if (parseToken(lltok::equal, "expected '=' here") || parseUInt32(Value))
1307 return true;
1308 Alignment = Align(Value);
1309 } else {
1310 if (parseOptionalAlignment(Alignment))
1311 return true;
1312 }
1313 B.addAlignmentAttr(Alignment);
1314 continue;
1315 }
1316 case lltok::kw_alignstack: {
1317 unsigned Alignment;
1318 if (inAttrGrp) {
1319 Lex.Lex();
1320 if (parseToken(lltok::equal, "expected '=' here") ||
1321 parseUInt32(Alignment))
1322 return true;
1323 } else {
1324 if (parseOptionalStackAlignment(Alignment))
1325 return true;
1326 }
1327 B.addStackAlignmentAttr(Alignment);
1328 continue;
1329 }
1330 case lltok::kw_allocsize: {
1331 unsigned ElemSizeArg;
1332 Optional<unsigned> NumElemsArg;
1333 // inAttrGrp doesn't matter; we only support allocsize(a[, b])
1334 if (parseAllocSizeArguments(ElemSizeArg, NumElemsArg))
1335 return true;
1336 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1337 continue;
1338 }
1339 case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
1340 case lltok::kw_argmemonly: B.addAttribute(Attribute::ArgMemOnly); break;
1341 case lltok::kw_builtin: B.addAttribute(Attribute::Builtin); break;
1342 case lltok::kw_cold: B.addAttribute(Attribute::Cold); break;
1343 case lltok::kw_hot: B.addAttribute(Attribute::Hot); break;
1344 case lltok::kw_convergent: B.addAttribute(Attribute::Convergent); break;
1345 case lltok::kw_inaccessiblememonly:
1346 B.addAttribute(Attribute::InaccessibleMemOnly); break;
1347 case lltok::kw_inaccessiblemem_or_argmemonly:
1348 B.addAttribute(Attribute::InaccessibleMemOrArgMemOnly); break;
1349 case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
1350 case lltok::kw_jumptable: B.addAttribute(Attribute::JumpTable); break;
1351 case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
1352 case lltok::kw_mustprogress:
1353 B.addAttribute(Attribute::MustProgress);
1354 break;
1355 case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
1356 case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
1357 case lltok::kw_nocallback:
1358 B.addAttribute(Attribute::NoCallback);
1359 break;
1360 case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
1361 case lltok::kw_nofree: B.addAttribute(Attribute::NoFree); break;
1362 case lltok::kw_noimplicitfloat:
1363 B.addAttribute(Attribute::NoImplicitFloat); break;
1364 case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
1365 case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
1366 case lltok::kw_nomerge: B.addAttribute(Attribute::NoMerge); break;
1367 case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
1368 case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
1369 case lltok::kw_nosync: B.addAttribute(Attribute::NoSync); break;
1370 case lltok::kw_nocf_check: B.addAttribute(Attribute::NoCfCheck); break;
1371 case lltok::kw_noprofile: B.addAttribute(Attribute::NoProfile); break;
1372 case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break;
1373 case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
1374 case lltok::kw_null_pointer_is_valid:
1375 B.addAttribute(Attribute::NullPointerIsValid); break;
1376 case lltok::kw_optforfuzzing:
1377 B.addAttribute(Attribute::OptForFuzzing); break;
1378 case lltok::kw_optnone: B.addAttribute(Attribute::OptimizeNone); break;
1379 case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
1380 case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
1381 case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
1382 case lltok::kw_returns_twice:
1383 B.addAttribute(Attribute::ReturnsTwice); break;
1384 case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break;
1385 case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
1386 case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
1387 case lltok::kw_sspstrong:
1388 B.addAttribute(Attribute::StackProtectStrong); break;
1389 case lltok::kw_safestack: B.addAttribute(Attribute::SafeStack); break;
1390 case lltok::kw_shadowcallstack:
1391 B.addAttribute(Attribute::ShadowCallStack); break;
1392 case lltok::kw_sanitize_address:
1393 B.addAttribute(Attribute::SanitizeAddress); break;
1394 case lltok::kw_sanitize_hwaddress:
1395 B.addAttribute(Attribute::SanitizeHWAddress); break;
1396 case lltok::kw_sanitize_memtag:
1397 B.addAttribute(Attribute::SanitizeMemTag); break;
1398 case lltok::kw_sanitize_thread:
1399 B.addAttribute(Attribute::SanitizeThread); break;
1400 case lltok::kw_sanitize_memory:
1401 B.addAttribute(Attribute::SanitizeMemory); break;
1402 case lltok::kw_speculative_load_hardening:
1403 B.addAttribute(Attribute::SpeculativeLoadHardening);
1404 break;
1405 case lltok::kw_strictfp: B.addAttribute(Attribute::StrictFP); break;
1406 case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
1407 case lltok::kw_willreturn: B.addAttribute(Attribute::WillReturn); break;
1408 case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
1409 case lltok::kw_preallocated: {
1410 Type *Ty;
1411 if (parsePreallocated(Ty))
1412 return true;
1413 B.addPreallocatedAttr(Ty);
1414 break;
1415 }
1416
1417 // error handling.
1418 case lltok::kw_inreg:
1419 case lltok::kw_signext:
1420 case lltok::kw_zeroext:
1421 HaveError |=
1422 error(Lex.getLoc(), "invalid use of attribute on a function");
1423 break;
1424 case lltok::kw_byval:
1425 case lltok::kw_dereferenceable:
1426 case lltok::kw_dereferenceable_or_null:
1427 case lltok::kw_inalloca:
1428 case lltok::kw_nest:
1429 case lltok::kw_noalias:
1430 case lltok::kw_noundef:
1431 case lltok::kw_nocapture:
1432 case lltok::kw_nonnull:
1433 case lltok::kw_returned:
1434 case lltok::kw_sret:
1435 case lltok::kw_swifterror:
1436 case lltok::kw_swiftself:
1437 case lltok::kw_immarg:
1438 case lltok::kw_byref:
1439 HaveError |=
1440 error(Lex.getLoc(),
1441 "invalid use of parameter-only attribute on a function");
1442 break;
1443 }
1444
1445 // parsePreallocated() consumes token
1446 if (Token != lltok::kw_preallocated)
1447 Lex.Lex();
1448 }
1449}
1450
1451//===----------------------------------------------------------------------===//
1452// GlobalValue Reference/Resolution Routines.
1453//===----------------------------------------------------------------------===//
1454
1455static inline GlobalValue *createGlobalFwdRef(Module *M, PointerType *PTy,
1456 const std::string &Name) {
1457 if (auto *FT = dyn_cast<FunctionType>(PTy->getElementType()))
1458 return Function::Create(FT, GlobalValue::ExternalWeakLinkage,
1459 PTy->getAddressSpace(), Name, M);
1460 else
1461 return new GlobalVariable(*M, PTy->getElementType(), false,
1462 GlobalValue::ExternalWeakLinkage, nullptr, Name,
1463 nullptr, GlobalVariable::NotThreadLocal,
1464 PTy->getAddressSpace());
1465}
1466
1467Value *LLParser::checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
1468 Value *Val, bool IsCall) {
1469 if (Val->getType() == Ty)
1470 return Val;
1471 // For calls we also accept variables in the program address space.
1472 Type *SuggestedTy = Ty;
1473 if (IsCall && isa<PointerType>(Ty)) {
1474 Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
1475 M->getDataLayout().getProgramAddressSpace());
1476 SuggestedTy = TyInProgAS;
1477 if (Val->getType() == TyInProgAS)
1478 return Val;
1479 }
1480 if (Ty->isLabelTy())
1481 error(Loc, "'" + Name + "' is not a basic block");
1482 else
1483 error(Loc, "'" + Name + "' defined with type '" +
1484 getTypeString(Val->getType()) + "' but expected '" +
1485 getTypeString(SuggestedTy) + "'");
1486 return nullptr;
1487}
1488
1489/// getGlobalVal - Get a value with the specified name or ID, creating a
1490/// forward reference record if needed. This can return null if the value
1491/// exists but does not have the right type.
1492GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty,
1493 LocTy Loc, bool IsCall) {
1494 PointerType *PTy = dyn_cast<PointerType>(Ty);
1495 if (!PTy) {
1496 error(Loc, "global variable reference must have pointer type");
1497 return nullptr;
1498 }
1499
1500 // Look this name up in the normal function symbol table.
1501 GlobalValue *Val =
1502 cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
1503
1504 // If this is a forward reference for the value, see if we already created a
1505 // forward ref record.
1506 if (!Val) {
1507 auto I = ForwardRefVals.find(Name);
1508 if (I != ForwardRefVals.end())
1509 Val = I->second.first;
1510 }
1511
1512 // If we have the value in the symbol table or fwd-ref table, return it.
1513 if (Val)
1514 return cast_or_null<GlobalValue>(
1515 checkValidVariableType(Loc, "@" + Name, Ty, Val, IsCall));
1516
1517 // Otherwise, create a new forward reference for this value and remember it.
1518 GlobalValue *FwdVal = createGlobalFwdRef(M, PTy, Name);
1519 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1520 return FwdVal;
1521}
1522
1523GlobalValue *LLParser::getGlobalVal(unsigned ID, Type *Ty, LocTy Loc,
1524 bool IsCall) {
1525 PointerType *PTy = dyn_cast<PointerType>(Ty);
1526 if (!PTy) {
1527 error(Loc, "global variable reference must have pointer type");
1528 return nullptr;
1529 }
1530
1531 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
1532
1533 // If this is a forward reference for the value, see if we already created a
1534 // forward ref record.
1535 if (!Val) {
1536 auto I = ForwardRefValIDs.find(ID);
1537 if (I != ForwardRefValIDs.end())
1538 Val = I->second.first;
1539 }
1540
1541 // If we have the value in the symbol table or fwd-ref table, return it.
1542 if (Val)
1543 return cast_or_null<GlobalValue>(
1544 checkValidVariableType(Loc, "@" + Twine(ID), Ty, Val, IsCall));
1545
1546 // Otherwise, create a new forward reference for this value and remember it.
1547 GlobalValue *FwdVal = createGlobalFwdRef(M, PTy, "");
1548 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1549 return FwdVal;
1550}
1551
1552//===----------------------------------------------------------------------===//
1553// Comdat Reference/Resolution Routines.
1554//===----------------------------------------------------------------------===//
1555
1556Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
1557 // Look this name up in the comdat symbol table.
1558 Module::ComdatSymTabType &ComdatSymTab = M->getComdatSymbolTable();
1559 Module::ComdatSymTabType::iterator I = ComdatSymTab.find(Name);
1560 if (I != ComdatSymTab.end())
1561 return &I->second;
1562
1563 // Otherwise, create a new forward reference for this value and remember it.
1564 Comdat *C = M->getOrInsertComdat(Name);
1565 ForwardRefComdats[Name] = Loc;
1566 return C;
1567}
1568
1569//===----------------------------------------------------------------------===//
1570// Helper Routines.
1571//===----------------------------------------------------------------------===//
1572
1573/// parseToken - If the current token has the specified kind, eat it and return
1574/// success. Otherwise, emit the specified error and return failure.
1575bool LLParser::parseToken(lltok::Kind T, const char *ErrMsg) {
1576 if (Lex.getKind() != T)
1577 return tokError(ErrMsg);
1578 Lex.Lex();
1579 return false;
1580}
1581
1582/// parseStringConstant
1583/// ::= StringConstant
1584bool LLParser::parseStringConstant(std::string &Result) {
1585 if (Lex.getKind() != lltok::StringConstant)
1586 return tokError("expected string constant");
1587 Result = Lex.getStrVal();
1588 Lex.Lex();
1589 return false;
1590}
1591
1592/// parseUInt32
1593/// ::= uint32
1594bool LLParser::parseUInt32(uint32_t &Val) {
1595 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1596 return tokError("expected integer");
1597 uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
1598 if (Val64 != unsigned(Val64))
1599 return tokError("expected 32-bit integer (too large)");
1600 Val = Val64;
1601 Lex.Lex();
1602 return false;
1603}
1604
1605/// parseUInt64
1606/// ::= uint64
1607bool LLParser::parseUInt64(uint64_t &Val) {
1608 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
1609 return tokError("expected integer");
1610 Val = Lex.getAPSIntVal().getLimitedValue();
1611 Lex.Lex();
1612 return false;
1613}
1614
1615/// parseTLSModel
1616/// := 'localdynamic'
1617/// := 'initialexec'
1618/// := 'localexec'
1619bool LLParser::parseTLSModel(GlobalVariable::ThreadLocalMode &TLM) {
1620 switch (Lex.getKind()) {
1621 default:
1622 return tokError("expected localdynamic, initialexec or localexec");
1623 case lltok::kw_localdynamic:
1624 TLM = GlobalVariable::LocalDynamicTLSModel;
1625 break;
1626 case lltok::kw_initialexec:
1627 TLM = GlobalVariable::InitialExecTLSModel;
1628 break;
1629 case lltok::kw_localexec:
1630 TLM = GlobalVariable::LocalExecTLSModel;
1631 break;
1632 }
1633
1634 Lex.Lex();
1635 return false;
1636}
1637
1638/// parseOptionalThreadLocal
1639/// := /*empty*/
1640/// := 'thread_local'
1641/// := 'thread_local' '(' tlsmodel ')'
1642bool LLParser::parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM) {
1643 TLM = GlobalVariable::NotThreadLocal;
1644 if (!EatIfPresent(lltok::kw_thread_local))
1645 return false;
1646
1647 TLM = GlobalVariable::GeneralDynamicTLSModel;
1648 if (Lex.getKind() == lltok::lparen) {
1649 Lex.Lex();
1650 return parseTLSModel(TLM) ||
1651 parseToken(lltok::rparen, "expected ')' after thread local model");
1652 }
1653 return false;
1654}
1655
1656/// parseOptionalAddrSpace
1657/// := /*empty*/
1658/// := 'addrspace' '(' uint32 ')'
1659bool LLParser::parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS) {
1660 AddrSpace = DefaultAS;
1661 if (!EatIfPresent(lltok::kw_addrspace))
1662 return false;
1663 return parseToken(lltok::lparen, "expected '(' in address space") ||
1664 parseUInt32(AddrSpace) ||
1665 parseToken(lltok::rparen, "expected ')' in address space");
1666}
1667
1668/// parseStringAttribute
1669/// := StringConstant
1670/// := StringConstant '=' StringConstant
1671bool LLParser::parseStringAttribute(AttrBuilder &B) {
1672 std::string Attr = Lex.getStrVal();
1673 Lex.Lex();
1674 std::string Val;
1675 if (EatIfPresent(lltok::equal) && parseStringConstant(Val))
1676 return true;
1677 B.addAttribute(Attr, Val);
1678 return false;
1679}
1680
1681/// parseOptionalParamAttrs - parse a potentially empty list of parameter
1682/// attributes.
1683bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) {
1684 bool HaveError = false;
1685
1686 B.clear();
1687
1688 while (true) {
1689 lltok::Kind Token = Lex.getKind();
1690 switch (Token) {
1691 default: // End of attributes.
1692 return HaveError;
1693 case lltok::StringConstant: {
1694 if (parseStringAttribute(B))
1695 return true;
1696 continue;
1697 }
1698 case lltok::kw_align: {
1699 MaybeAlign Alignment;
1700 if (parseOptionalAlignment(Alignment, true))
1701 return true;
1702 B.addAlignmentAttr(Alignment);
1703 continue;
1704 }
1705 case lltok::kw_byval: {
1706 Type *Ty;
1707 if (parseRequiredTypeAttr(Ty, lltok::kw_byval))
1708 return true;
1709 B.addByValAttr(Ty);
1710 continue;
1711 }
1712 case lltok::kw_sret: {
1713 Type *Ty;
1714 if (parseRequiredTypeAttr(Ty, lltok::kw_sret))
1715 return true;
1716 B.addStructRetAttr(Ty);
1717 continue;
1718 }
1719 case lltok::kw_preallocated: {
1720 Type *Ty;
1721 if (parsePreallocated(Ty))
1722 return true;
1723 B.addPreallocatedAttr(Ty);
1724 continue;
1725 }
1726 case lltok::kw_dereferenceable: {
1727 uint64_t Bytes;
1728 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1729 return true;
1730 B.addDereferenceableAttr(Bytes);
1731 continue;
1732 }
1733 case lltok::kw_dereferenceable_or_null: {
1734 uint64_t Bytes;
1735 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1736 return true;
1737 B.addDereferenceableOrNullAttr(Bytes);
1738 continue;
1739 }
1740 case lltok::kw_byref: {
1741 Type *Ty;
1742 if (parseByRef(Ty))
1743 return true;
1744 B.addByRefAttr(Ty);
1745 continue;
1746 }
1747 case lltok::kw_inalloca: B.addAttribute(Attribute::InAlloca); break;
1748 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1749 case lltok::kw_nest: B.addAttribute(Attribute::Nest); break;
1750 case lltok::kw_noundef:
1751 B.addAttribute(Attribute::NoUndef);
1752 break;
1753 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1754 case lltok::kw_nocapture: B.addAttribute(Attribute::NoCapture); break;
1755 case lltok::kw_nofree: B.addAttribute(Attribute::NoFree); break;
1756 case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
1757 case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
1758 case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
1759 case lltok::kw_returned: B.addAttribute(Attribute::Returned); break;
1760 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1761 case lltok::kw_swifterror: B.addAttribute(Attribute::SwiftError); break;
1762 case lltok::kw_swiftself: B.addAttribute(Attribute::SwiftSelf); break;
1763 case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
1764 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1765 case lltok::kw_immarg: B.addAttribute(Attribute::ImmArg); break;
1766
1767 case lltok::kw_alignstack:
1768 case lltok::kw_alwaysinline:
1769 case lltok::kw_argmemonly:
1770 case lltok::kw_builtin:
1771 case lltok::kw_inlinehint:
1772 case lltok::kw_jumptable:
1773 case lltok::kw_minsize:
1774 case lltok::kw_mustprogress:
1775 case lltok::kw_naked:
1776 case lltok::kw_nobuiltin:
1777 case lltok::kw_noduplicate:
1778 case lltok::kw_noimplicitfloat:
1779 case lltok::kw_noinline:
1780 case lltok::kw_nonlazybind:
1781 case lltok::kw_nomerge:
1782 case lltok::kw_noprofile:
1783 case lltok::kw_noredzone:
1784 case lltok::kw_noreturn:
1785 case lltok::kw_nocf_check:
1786 case lltok::kw_nounwind:
1787 case lltok::kw_optforfuzzing:
1788 case lltok::kw_optnone:
1789 case lltok::kw_optsize:
1790 case lltok::kw_returns_twice:
1791 case lltok::kw_sanitize_address:
1792 case lltok::kw_sanitize_hwaddress:
1793 case lltok::kw_sanitize_memtag:
1794 case lltok::kw_sanitize_memory:
1795 case lltok::kw_sanitize_thread:
1796 case lltok::kw_speculative_load_hardening:
1797 case lltok::kw_ssp:
1798 case lltok::kw_sspreq:
1799 case lltok::kw_sspstrong:
1800 case lltok::kw_safestack:
1801 case lltok::kw_shadowcallstack:
1802 case lltok::kw_strictfp:
1803 case lltok::kw_uwtable:
1804 HaveError |=
1805 error(Lex.getLoc(), "invalid use of function-only attribute");
1806 break;
1807 }
1808
1809 Lex.Lex();
1810 }
1811}
1812
1813/// parseOptionalReturnAttrs - parse a potentially empty list of return
1814/// attributes.
1815bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) {
1816 bool HaveError = false;
1817
1818 B.clear();
1819
1820 while (true) {
1821 lltok::Kind Token = Lex.getKind();
1822 switch (Token) {
1823 default: // End of attributes.
1824 return HaveError;
1825 case lltok::StringConstant: {
1826 if (parseStringAttribute(B))
1827 return true;
1828 continue;
1829 }
1830 case lltok::kw_dereferenceable: {
1831 uint64_t Bytes;
1832 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable, Bytes))
1833 return true;
1834 B.addDereferenceableAttr(Bytes);
1835 continue;
1836 }
1837 case lltok::kw_dereferenceable_or_null: {
1838 uint64_t Bytes;
1839 if (parseOptionalDerefAttrBytes(lltok::kw_dereferenceable_or_null, Bytes))
1840 return true;
1841 B.addDereferenceableOrNullAttr(Bytes);
1842 continue;
1843 }
1844 case lltok::kw_align: {
1845 MaybeAlign Alignment;
1846 if (parseOptionalAlignment(Alignment))
1847 return true;
1848 B.addAlignmentAttr(Alignment);
1849 continue;
1850 }
1851 case lltok::kw_inreg: B.addAttribute(Attribute::InReg); break;
1852 case lltok::kw_noalias: B.addAttribute(Attribute::NoAlias); break;
1853 case lltok::kw_noundef:
1854 B.addAttribute(Attribute::NoUndef);
1855 break;
1856 case lltok::kw_nonnull: B.addAttribute(Attribute::NonNull); break;
1857 case lltok::kw_signext: B.addAttribute(Attribute::SExt); break;
1858 case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
1859
1860 // error handling.
1861 case lltok::kw_byval:
1862 case lltok::kw_inalloca:
1863 case lltok::kw_nest:
1864 case lltok::kw_nocapture:
1865 case lltok::kw_returned:
1866 case lltok::kw_sret:
1867 case lltok::kw_swifterror:
1868 case lltok::kw_swiftself:
1869 case lltok::kw_immarg:
1870 case lltok::kw_byref:
1871 HaveError |=
1872 error(Lex.getLoc(), "invalid use of parameter-only attribute");
1873 break;
1874
1875 case lltok::kw_alignstack:
1876 case lltok::kw_alwaysinline:
1877 case lltok::kw_argmemonly:
1878 case lltok::kw_builtin:
1879 case lltok::kw_cold:
1880 case lltok::kw_inlinehint:
1881 case lltok::kw_jumptable:
1882 case lltok::kw_minsize:
1883 case lltok::kw_mustprogress:
1884 case lltok::kw_naked:
1885 case lltok::kw_nobuiltin:
1886 case lltok::kw_noduplicate:
1887 case lltok::kw_noimplicitfloat:
1888 case lltok::kw_noinline:
1889 case lltok::kw_nonlazybind:
1890 case lltok::kw_nomerge:
1891 case lltok::kw_noprofile:
1892 case lltok::kw_noredzone:
1893 case lltok::kw_noreturn:
1894 case lltok::kw_nocf_check:
1895 case lltok::kw_nounwind:
1896 case lltok::kw_optforfuzzing:
1897 case lltok::kw_optnone:
1898 case lltok::kw_optsize:
1899 case lltok::kw_returns_twice:
1900 case lltok::kw_sanitize_address:
1901 case lltok::kw_sanitize_hwaddress:
1902 case lltok::kw_sanitize_memtag:
1903 case lltok::kw_sanitize_memory:
1904 case lltok::kw_sanitize_thread:
1905 case lltok::kw_speculative_load_hardening:
1906 case lltok::kw_ssp:
1907 case lltok::kw_sspreq:
1908 case lltok::kw_sspstrong:
1909 case lltok::kw_safestack:
1910 case lltok::kw_shadowcallstack:
1911 case lltok::kw_strictfp:
1912 case lltok::kw_uwtable:
1913 HaveError |=
1914 error(Lex.getLoc(), "invalid use of function-only attribute");
1915 break;
1916 case lltok::kw_readnone:
1917 case lltok::kw_readonly:
1918 HaveError |=
1919 error(Lex.getLoc(), "invalid use of attribute on return type");
1920 break;
1921 case lltok::kw_preallocated:
1922 HaveError |=
1923 error(Lex.getLoc(),
1924 "invalid use of parameter-only/call site-only attribute");
1925 break;
1926 }
1927
1928 Lex.Lex();
1929 }
1930}
1931
1932static unsigned parseOptionalLinkageAux(lltok::Kind Kind, bool &HasLinkage) {
1933 HasLinkage = true;
1934 switch (Kind) {
1935 default:
1936 HasLinkage = false;
1937 return GlobalValue::ExternalLinkage;
1938 case lltok::kw_private:
1939 return GlobalValue::PrivateLinkage;
1940 case lltok::kw_internal:
1941 return GlobalValue::InternalLinkage;
1942 case lltok::kw_weak:
1943 return GlobalValue::WeakAnyLinkage;
1944 case lltok::kw_weak_odr:
1945 return GlobalValue::WeakODRLinkage;
1946 case lltok::kw_linkonce:
1947 return GlobalValue::LinkOnceAnyLinkage;
1948 case lltok::kw_linkonce_odr:
1949 return GlobalValue::LinkOnceODRLinkage;
1950 case lltok::kw_available_externally:
1951 return GlobalValue::AvailableExternallyLinkage;
1952 case lltok::kw_appending:
1953 return GlobalValue::AppendingLinkage;
1954 case lltok::kw_common:
1955 return GlobalValue::CommonLinkage;
1956 case lltok::kw_extern_weak:
1957 return GlobalValue::ExternalWeakLinkage;
1958 case lltok::kw_external:
1959 return GlobalValue::ExternalLinkage;
1960 }
1961}
1962
1963/// parseOptionalLinkage
1964/// ::= /*empty*/
1965/// ::= 'private'
1966/// ::= 'internal'
1967/// ::= 'weak'
1968/// ::= 'weak_odr'
1969/// ::= 'linkonce'
1970/// ::= 'linkonce_odr'
1971/// ::= 'available_externally'
1972/// ::= 'appending'
1973/// ::= 'common'
1974/// ::= 'extern_weak'
1975/// ::= 'external'
1976bool LLParser::parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
1977 unsigned &Visibility,
1978 unsigned &DLLStorageClass, bool &DSOLocal) {
1979 Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
1980 if (HasLinkage)
1981 Lex.Lex();
1982 parseOptionalDSOLocal(DSOLocal);
1983 parseOptionalVisibility(Visibility);
1984 parseOptionalDLLStorageClass(DLLStorageClass);
1985
1986 if (DSOLocal && DLLStorageClass == GlobalValue::DLLImportStorageClass) {
1987 return error(Lex.getLoc(), "dso_location and DLL-StorageClass mismatch");
1988 }
1989
1990 return false;
1991}
1992
1993void LLParser::parseOptionalDSOLocal(bool &DSOLocal) {
1994 switch (Lex.getKind()) {
1995 default:
1996 DSOLocal = false;
1997 break;
1998 case lltok::kw_dso_local:
1999 DSOLocal = true;
2000 Lex.Lex();
2001 break;
2002 case lltok::kw_dso_preemptable:
2003 DSOLocal = false;
2004 Lex.Lex();
2005 break;
2006 }
2007}
2008
2009/// parseOptionalVisibility
2010/// ::= /*empty*/
2011/// ::= 'default'
2012/// ::= 'hidden'
2013/// ::= 'protected'
2014///
2015void LLParser::parseOptionalVisibility(unsigned &Res) {
2016 switch (Lex.getKind()) {
2017 default:
2018 Res = GlobalValue::DefaultVisibility;
2019 return;
2020 case lltok::kw_default:
2021 Res = GlobalValue::DefaultVisibility;
2022 break;
2023 case lltok::kw_hidden:
2024 Res = GlobalValue::HiddenVisibility;
2025 break;
2026 case lltok::kw_protected:
2027 Res = GlobalValue::ProtectedVisibility;
2028 break;
2029 }
2030 Lex.Lex();
2031}
2032
2033/// parseOptionalDLLStorageClass
2034/// ::= /*empty*/
2035/// ::= 'dllimport'
2036/// ::= 'dllexport'
2037///
2038void LLParser::parseOptionalDLLStorageClass(unsigned &Res) {
2039 switch (Lex.getKind()) {
2040 default:
2041 Res = GlobalValue::DefaultStorageClass;
2042 return;
2043 case lltok::kw_dllimport:
2044 Res = GlobalValue::DLLImportStorageClass;
2045 break;
2046 case lltok::kw_dllexport:
2047 Res = GlobalValue::DLLExportStorageClass;
2048 break;
2049 }
2050 Lex.Lex();
2051}
2052
2053/// parseOptionalCallingConv
2054/// ::= /*empty*/
2055/// ::= 'ccc'
2056/// ::= 'fastcc'
2057/// ::= 'intel_ocl_bicc'
2058/// ::= 'coldcc'
2059/// ::= 'cfguard_checkcc'
2060/// ::= 'x86_stdcallcc'
2061/// ::= 'x86_fastcallcc'
2062/// ::= 'x86_thiscallcc'
2063/// ::= 'x86_vectorcallcc'
2064/// ::= 'arm_apcscc'
2065/// ::= 'arm_aapcscc'
2066/// ::= 'arm_aapcs_vfpcc'
2067/// ::= 'aarch64_vector_pcs'
2068/// ::= 'aarch64_sve_vector_pcs'
2069/// ::= 'msp430_intrcc'
2070/// ::= 'avr_intrcc'
2071/// ::= 'avr_signalcc'
2072/// ::= 'ptx_kernel'
2073/// ::= 'ptx_device'
2074/// ::= 'spir_func'
2075/// ::= 'spir_kernel'
2076/// ::= 'x86_64_sysvcc'
2077/// ::= 'win64cc'
2078/// ::= 'webkit_jscc'
2079/// ::= 'anyregcc'
2080/// ::= 'preserve_mostcc'
2081/// ::= 'preserve_allcc'
2082/// ::= 'ghccc'
2083/// ::= 'swiftcc'
2084/// ::= 'x86_intrcc'
2085/// ::= 'hhvmcc'
2086/// ::= 'hhvm_ccc'
2087/// ::= 'cxx_fast_tlscc'
2088/// ::= 'amdgpu_vs'
2089/// ::= 'amdgpu_ls'
2090/// ::= 'amdgpu_hs'
2091/// ::= 'amdgpu_es'
2092/// ::= 'amdgpu_gs'
2093/// ::= 'amdgpu_ps'
2094/// ::= 'amdgpu_cs'
2095/// ::= 'amdgpu_kernel'
2096/// ::= 'tailcc'
2097/// ::= 'cc' UINT
2098///
2099bool LLParser::parseOptionalCallingConv(unsigned &CC) {
2100 switch (Lex.getKind()) {
2101 default: CC = CallingConv::C; return false;
2102 case lltok::kw_ccc: CC = CallingConv::C; break;
2103 case lltok::kw_fastcc: CC = CallingConv::Fast; break;
2104 case lltok::kw_coldcc: CC = CallingConv::Cold; break;
2105 case lltok::kw_cfguard_checkcc: CC = CallingConv::CFGuard_Check; break;
2106 case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break;
2107 case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
2108 case lltok::kw_x86_regcallcc: CC = CallingConv::X86_RegCall; break;
2109 case lltok::kw_x86_thiscallcc: CC = CallingConv::X86_ThisCall; break;
2110 case lltok::kw_x86_vectorcallcc:CC = CallingConv::X86_VectorCall; break;
2111 case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break;
2112 case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break;
2113 case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
2114 case lltok::kw_aarch64_vector_pcs:CC = CallingConv::AArch64_VectorCall; break;
2115 case lltok::kw_aarch64_sve_vector_pcs:
2116 CC = CallingConv::AArch64_SVE_VectorCall;
2117 break;
2118 case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break;
2119 case lltok::kw_avr_intrcc: CC = CallingConv::AVR_INTR; break;
2120 case lltok::kw_avr_signalcc: CC = CallingConv::AVR_SIGNAL; break;
2121 case lltok::kw_ptx_kernel: CC = CallingConv::PTX_Kernel; break;
2122 case lltok::kw_ptx_device: CC = CallingConv::PTX_Device; break;
2123 case lltok::kw_spir_kernel: CC = CallingConv::SPIR_KERNEL; break;
2124 case lltok::kw_spir_func: CC = CallingConv::SPIR_FUNC; break;
2125 case lltok::kw_intel_ocl_bicc: CC = CallingConv::Intel_OCL_BI; break;
2126 case lltok::kw_x86_64_sysvcc: CC = CallingConv::X86_64_SysV; break;
2127 case lltok::kw_win64cc: CC = CallingConv::Win64; break;
2128 case lltok::kw_webkit_jscc: CC = CallingConv::WebKit_JS; break;
2129 case lltok::kw_anyregcc: CC = CallingConv::AnyReg; break;
2130 case lltok::kw_preserve_mostcc:CC = CallingConv::PreserveMost; break;
2131 case lltok::kw_preserve_allcc: CC = CallingConv::PreserveAll; break;
2132 case lltok::kw_ghccc: CC = CallingConv::GHC; break;
2133 case lltok::kw_swiftcc: CC = CallingConv::Swift; break;
2134 case lltok::kw_x86_intrcc: CC = CallingConv::X86_INTR; break;
2135 case lltok::kw_hhvmcc: CC = CallingConv::HHVM; break;
2136 case lltok::kw_hhvm_ccc: CC = CallingConv::HHVM_C; break;
2137 case lltok::kw_cxx_fast_tlscc: CC = CallingConv::CXX_FAST_TLS; break;
2138 case lltok::kw_amdgpu_vs: CC = CallingConv::AMDGPU_VS; break;
2139 case lltok::kw_amdgpu_gfx: CC = CallingConv::AMDGPU_Gfx; break;
2140 case lltok::kw_amdgpu_ls: CC = CallingConv::AMDGPU_LS; break;
2141 case lltok::kw_amdgpu_hs: CC = CallingConv::AMDGPU_HS; break;
2142 case lltok::kw_amdgpu_es: CC = CallingConv::AMDGPU_ES; break;
2143 case lltok::kw_amdgpu_gs: CC = CallingConv::AMDGPU_GS; break;
2144 case lltok::kw_amdgpu_ps: CC = CallingConv::AMDGPU_PS; break;
2145 case lltok::kw_amdgpu_cs: CC = CallingConv::AMDGPU_CS; break;
2146 case lltok::kw_amdgpu_kernel: CC = CallingConv::AMDGPU_KERNEL; break;
2147 case lltok::kw_tailcc: CC = CallingConv::Tail; break;
2148 case lltok::kw_cc: {
2149 Lex.Lex();
2150 return parseUInt32(CC);
2151 }
2152 }
2153
2154 Lex.Lex();
2155 return false;
2156}
2157
2158/// parseMetadataAttachment
2159/// ::= !dbg !42
2160bool LLParser::parseMetadataAttachment(unsigned &Kind, MDNode *&MD) {
2161 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata attachment");
2162
2163 std::string Name = Lex.getStrVal();
2164 Kind = M->getMDKindID(Name);
2165 Lex.Lex();
2166
2167 return parseMDNode(MD);
2168}
2169
2170/// parseInstructionMetadata
2171/// ::= !dbg !42 (',' !dbg !57)*
2172bool LLParser::parseInstructionMetadata(Instruction &Inst) {
2173 do {
2174 if (Lex.getKind() != lltok::MetadataVar)
2175 return tokError("expected metadata after comma");
2176
2177 unsigned MDK;
2178 MDNode *N;
2179 if (parseMetadataAttachment(MDK, N))
2180 return true;
2181
2182 Inst.setMetadata(MDK, N);
2183 if (MDK == LLVMContext::MD_tbaa)
2184 InstsWithTBAATag.push_back(&Inst);
2185
2186 // If this is the end of the list, we're done.
2187 } while (EatIfPresent(lltok::comma));
2188 return false;
2189}
2190
2191/// parseGlobalObjectMetadataAttachment
2192/// ::= !dbg !57
2193bool LLParser::parseGlobalObjectMetadataAttachment(GlobalObject &GO) {
2194 unsigned MDK;
2195 MDNode *N;
2196 if (parseMetadataAttachment(MDK, N))
2197 return true;
2198
2199 GO.addMetadata(MDK, *N);
2200 return false;
2201}
2202
2203/// parseOptionalFunctionMetadata
2204/// ::= (!dbg !57)*
2205bool LLParser::parseOptionalFunctionMetadata(Function &F) {
2206 while (Lex.getKind() == lltok::MetadataVar)
2207 if (parseGlobalObjectMetadataAttachment(F))
2208 return true;
2209 return false;
2210}
2211
2212/// parseOptionalAlignment
2213/// ::= /* empty */
2214/// ::= 'align' 4
2215bool LLParser::parseOptionalAlignment(MaybeAlign &Alignment, bool AllowParens) {
2216 Alignment = None;
2217 if (!EatIfPresent(lltok::kw_align))
2218 return false;
2219 LocTy AlignLoc = Lex.getLoc();
2220 uint32_t Value = 0;
2221
2222 LocTy ParenLoc = Lex.getLoc();
2223 bool HaveParens = false;
2224 if (AllowParens) {
2225 if (EatIfPresent(lltok::lparen))
2226 HaveParens = true;
2227 }
2228
2229 if (parseUInt32(Value))
2230 return true;
2231
2232 if (HaveParens && !EatIfPresent(lltok::rparen))
2233 return error(ParenLoc, "expected ')'");
2234
2235 if (!isPowerOf2_32(Value))
2236 return error(AlignLoc, "alignment is not a power of two");
2237 if (Value > Value::MaximumAlignment)
2238 return error(AlignLoc, "huge alignments are not supported yet");
2239 Alignment = Align(Value);
2240 return false;
2241}
2242
2243/// parseOptionalDerefAttrBytes
2244/// ::= /* empty */
2245/// ::= AttrKind '(' 4 ')'
2246///
2247/// where AttrKind is either 'dereferenceable' or 'dereferenceable_or_null'.
2248bool LLParser::parseOptionalDerefAttrBytes(lltok::Kind AttrKind,
2249 uint64_t &Bytes) {
2250 assert((AttrKind == lltok::kw_dereferenceable ||
2251 AttrKind == lltok::kw_dereferenceable_or_null) &&
2252 "contract!");
2253
2254 Bytes = 0;
2255 if (!EatIfPresent(AttrKind))
2256 return false;
2257 LocTy ParenLoc = Lex.getLoc();
2258 if (!EatIfPresent(lltok::lparen))
2259 return error(ParenLoc, "expected '('");
2260 LocTy DerefLoc = Lex.getLoc();
2261 if (parseUInt64(Bytes))
2262 return true;
2263 ParenLoc = Lex.getLoc();
2264 if (!EatIfPresent(lltok::rparen))
2265 return error(ParenLoc, "expected ')'");
2266 if (!Bytes)
2267 return error(DerefLoc, "dereferenceable bytes must be non-zero");
2268 return false;
2269}
2270
2271/// parseOptionalCommaAlign
2272/// ::=
2273/// ::= ',' align 4
2274///
2275/// This returns with AteExtraComma set to true if it ate an excess comma at the
2276/// end.
2277bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment,
2278 bool &AteExtraComma) {
2279 AteExtraComma = false;
2280 while (EatIfPresent(lltok::comma)) {
2281 // Metadata at the end is an early exit.
2282 if (Lex.getKind() == lltok::MetadataVar) {
2283 AteExtraComma = true;
2284 return false;
2285 }
2286
2287 if (Lex.getKind() != lltok::kw_align)
2288 return error(Lex.getLoc(), "expected metadata or 'align'");
2289
2290 if (parseOptionalAlignment(Alignment))
2291 return true;
2292 }
2293
2294 return false;
2295}
2296
2297/// parseOptionalCommaAddrSpace
2298/// ::=
2299/// ::= ',' addrspace(1)
2300///
2301/// This returns with AteExtraComma set to true if it ate an excess comma at the
2302/// end.
2303bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
2304 bool &AteExtraComma) {
2305 AteExtraComma = false;
2306 while (EatIfPresent(lltok::comma)) {
2307 // Metadata at the end is an early exit.
2308 if (Lex.getKind() == lltok::MetadataVar) {
2309 AteExtraComma = true;
2310 return false;
2311 }
2312
2313 Loc = Lex.getLoc();
2314 if (Lex.getKind() != lltok::kw_addrspace)
2315 return error(Lex.getLoc(), "expected metadata or 'addrspace'");
2316
2317 if (parseOptionalAddrSpace(AddrSpace))
2318 return true;
2319 }
2320
2321 return false;
2322}
2323
2324bool LLParser::parseAllocSizeArguments(unsigned &BaseSizeArg,
2325 Optional<unsigned> &HowManyArg) {
2326 Lex.Lex();
2327
2328 auto StartParen = Lex.getLoc();
2329 if (!EatIfPresent(lltok::lparen))
2330 return error(StartParen, "expected '('");
2331
2332 if (parseUInt32(BaseSizeArg))
2333 return true;
2334
2335 if (EatIfPresent(lltok::comma)) {
2336 auto HowManyAt = Lex.getLoc();
2337 unsigned HowMany;
2338 if (parseUInt32(HowMany))
2339 return true;
2340 if (HowMany == BaseSizeArg)
2341 return error(HowManyAt,
2342 "'allocsize' indices can't refer to the same parameter");
2343 HowManyArg = HowMany;
2344 } else
2345 HowManyArg = None;
2346
2347 auto EndParen = Lex.getLoc();
2348 if (!EatIfPresent(lltok::rparen))
2349 return error(EndParen, "expected ')'");
2350 return false;
2351}
2352
2353/// parseScopeAndOrdering
2354/// if isAtomic: ::= SyncScope? AtomicOrdering
2355/// else: ::=
2356///
2357/// This sets Scope and Ordering to the parsed values.
2358bool LLParser::parseScopeAndOrdering(bool IsAtomic, SyncScope::ID &SSID,
2359 AtomicOrdering &Ordering) {
2360 if (!IsAtomic)
2361 return false;
2362
2363 return parseScope(SSID) || parseOrdering(Ordering);
2364}
2365
2366/// parseScope
2367/// ::= syncscope("singlethread" | "<target scope>")?
2368///
2369/// This sets synchronization scope ID to the ID of the parsed value.
2370bool LLParser::parseScope(SyncScope::ID &SSID) {
2371 SSID = SyncScope::System;
2372 if (EatIfPresent(lltok::kw_syncscope)) {
2373 auto StartParenAt = Lex.getLoc();
2374 if (!EatIfPresent(lltok::lparen))
2375 return error(StartParenAt, "Expected '(' in syncscope");
2376
2377 std::string SSN;
2378 auto SSNAt = Lex.getLoc();
2379 if (parseStringConstant(SSN))
2380 return error(SSNAt, "Expected synchronization scope name");
2381
2382 auto EndParenAt = Lex.getLoc();
2383 if (!EatIfPresent(lltok::rparen))
2384 return error(EndParenAt, "Expected ')' in syncscope");
2385
2386 SSID = Context.getOrInsertSyncScopeID(SSN);
2387 }
2388
2389 return false;
2390}
2391
2392/// parseOrdering
2393/// ::= AtomicOrdering
2394///
2395/// This sets Ordering to the parsed value.
2396bool LLParser::parseOrdering(AtomicOrdering &Ordering) {
2397 switch (Lex.getKind()) {
2398 default:
2399 return tokError("Expected ordering on atomic instruction");
2400 case lltok::kw_unordered: Ordering = AtomicOrdering::Unordered; break;
2401 case lltok::kw_monotonic: Ordering = AtomicOrdering::Monotonic; break;
2402 // Not specified yet:
2403 // case lltok::kw_consume: Ordering = AtomicOrdering::Consume; break;
2404 case lltok::kw_acquire: Ordering = AtomicOrdering::Acquire; break;
2405 case lltok::kw_release: Ordering = AtomicOrdering::Release; break;
2406 case lltok::kw_acq_rel: Ordering = AtomicOrdering::AcquireRelease; break;
2407 case lltok::kw_seq_cst:
2408 Ordering = AtomicOrdering::SequentiallyConsistent;
2409 break;
2410 }
2411 Lex.Lex();
2412 return false;
2413}
2414
2415/// parseOptionalStackAlignment
2416/// ::= /* empty */
2417/// ::= 'alignstack' '(' 4 ')'
2418bool LLParser::parseOptionalStackAlignment(unsigned &Alignment) {
2419 Alignment = 0;
2420 if (!EatIfPresent(lltok::kw_alignstack))
2421 return false;
2422 LocTy ParenLoc = Lex.getLoc();
2423 if (!EatIfPresent(lltok::lparen))
2424 return error(ParenLoc, "expected '('");
2425 LocTy AlignLoc = Lex.getLoc();
2426 if (parseUInt32(Alignment))
2427 return true;
2428 ParenLoc = Lex.getLoc();
2429 if (!EatIfPresent(lltok::rparen))
2430 return error(ParenLoc, "expected ')'");
2431 if (!isPowerOf2_32(Alignment))
2432 return error(AlignLoc, "stack alignment is not a power of two");
2433 return false;
2434}
2435
2436/// parseIndexList - This parses the index list for an insert/extractvalue
2437/// instruction. This sets AteExtraComma in the case where we eat an extra
2438/// comma at the end of the line and find that it is followed by metadata.
2439/// Clients that don't allow metadata can call the version of this function that
2440/// only takes one argument.
2441///
2442/// parseIndexList
2443/// ::= (',' uint32)+
2444///
2445bool LLParser::parseIndexList(SmallVectorImpl<unsigned> &Indices,
2446 bool &AteExtraComma) {
2447 AteExtraComma = false;
2448
2449 if (Lex.getKind() != lltok::comma)
2450 return tokError("expected ',' as start of index list");
2451
2452 while (EatIfPresent(lltok::comma)) {
2453 if (Lex.getKind() == lltok::MetadataVar) {
2454 if (Indices.empty())
2455 return tokError("expected index");
2456 AteExtraComma = true;
2457 return false;
2458 }
2459 unsigned Idx = 0;
2460 if (parseUInt32(Idx))
2461 return true;
2462 Indices.push_back(Idx);
2463 }
2464
2465 return false;
2466}
2467
2468//===----------------------------------------------------------------------===//
2469// Type Parsing.
2470//===----------------------------------------------------------------------===//
2471
2472/// parseType - parse a type.
2473bool LLParser::parseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
2474 SMLoc TypeLoc = Lex.getLoc();
2475 switch (Lex.getKind()) {
2476 default:
2477 return tokError(Msg);
2478 case lltok::Type:
2479 // Type ::= 'float' | 'void' (etc)
2480 Result = Lex.getTyVal();
2481 Lex.Lex();
2482 break;
2483 case lltok::lbrace:
2484 // Type ::= StructType
2485 if (parseAnonStructType(Result, false))
2486 return true;
2487 break;
2488 case lltok::lsquare:
2489 // Type ::= '[' ... ']'
2490 Lex.Lex(); // eat the lsquare.
2491 if (parseArrayVectorType(Result, false))
2492 return true;
2493 break;
2494 case lltok::less: // Either vector or packed struct.
2495 // Type ::= '<' ... '>'
2496 Lex.Lex();
2497 if (Lex.getKind() == lltok::lbrace) {
2498 if (parseAnonStructType(Result, true) ||
2499 parseToken(lltok::greater, "expected '>' at end of packed struct"))
2500 return true;
2501 } else if (parseArrayVectorType(Result, true))
2502 return true;
2503 break;
2504 case lltok::LocalVar: {
2505 // Type ::= %foo
2506 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
2507
2508 // If the type hasn't been defined yet, create a forward definition and
2509 // remember where that forward def'n was seen (in case it never is defined).
2510 if (!Entry.first) {
2511 Entry.first = StructType::create(Context, Lex.getStrVal());
2512 Entry.second = Lex.getLoc();
2513 }
2514 Result = Entry.first;
2515 Lex.Lex();
2516 break;
2517 }
2518
2519 case lltok::LocalVarID: {
2520 // Type ::= %4
2521 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
2522
2523 // If the type hasn't been defined yet, create a forward definition and
2524 // remember where that forward def'n was seen (in case it never is defined).
2525 if (!Entry.first) {
2526 Entry.first = StructType::create(Context);
2527 Entry.second = Lex.getLoc();
2528 }
2529 Result = Entry.first;
2530 Lex.Lex();
2531 break;
2532 }
2533 }
2534
2535 // parse the type suffixes.
2536 while (true) {
2537 switch (Lex.getKind()) {
2538 // End of type.
2539 default:
2540 if (!AllowVoid && Result->isVoidTy())
2541 return error(TypeLoc, "void type only allowed for function results");
2542 return false;
2543
2544 // Type ::= Type '*'
2545 case lltok::star:
2546 if (Result->isLabelTy())
2547 return tokError("basic block pointers are invalid");
2548 if (Result->isVoidTy())
2549 return tokError("pointers to void are invalid - use i8* instead");
2550 if (!PointerType::isValidElementType(Result))
2551 return tokError("pointer to this type is invalid");
2552 Result = PointerType::getUnqual(Result);
2553 Lex.Lex();
2554 break;
2555
2556 // Type ::= Type 'addrspace' '(' uint32 ')' '*'
2557 case lltok::kw_addrspace: {
2558 if (Result->isLabelTy())
2559 return tokError("basic block pointers are invalid");
2560 if (Result->isVoidTy())
2561 return tokError("pointers to void are invalid; use i8* instead");
2562 if (!PointerType::isValidElementType(Result))
2563 return tokError("pointer to this type is invalid");
2564 unsigned AddrSpace;
2565 if (parseOptionalAddrSpace(AddrSpace) ||
2566 parseToken(lltok::star, "expected '*' in address space"))
2567 return true;
2568
2569 Result = PointerType::get(Result, AddrSpace);
2570 break;
2571 }
2572
2573 /// Types '(' ArgTypeListI ')' OptFuncAttrs
2574 case lltok::lparen:
2575 if (parseFunctionType(Result))
2576 return true;
2577 break;
2578 }
2579 }
2580}
2581
2582/// parseParameterList
2583/// ::= '(' ')'
2584/// ::= '(' Arg (',' Arg)* ')'
2585/// Arg
2586/// ::= Type OptionalAttributes Value OptionalAttributes
2587bool LLParser::parseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
2588 PerFunctionState &PFS, bool IsMustTailCall,
2589 bool InVarArgsFunc) {
2590 if (parseToken(lltok::lparen, "expected '(' in call"))
2591 return true;
2592
2593 while (Lex.getKind() != lltok::rparen) {
2594 // If this isn't the first argument, we need a comma.
2595 if (!ArgList.empty() &&
2596 parseToken(lltok::comma, "expected ',' in argument list"))
2597 return true;
2598
2599 // parse an ellipsis if this is a musttail call in a variadic function.
2600 if (Lex.getKind() == lltok::dotdotdot) {
2601 const char *Msg = "unexpected ellipsis in argument list for ";
2602 if (!IsMustTailCall)
2603 return tokError(Twine(Msg) + "non-musttail call");
2604 if (!InVarArgsFunc)
2605 return tokError(Twine(Msg) + "musttail call in non-varargs function");
2606 Lex.Lex(); // Lex the '...', it is purely for readability.
2607 return parseToken(lltok::rparen, "expected ')' at end of argument list");
2608 }
2609
2610 // parse the argument.
2611 LocTy ArgLoc;
2612 Type *ArgTy = nullptr;
2613 AttrBuilder ArgAttrs;
2614 Value *V;
2615 if (parseType(ArgTy, ArgLoc))
2616 return true;
2617
2618 if (ArgTy->isMetadataTy()) {
2619 if (parseMetadataAsValue(V, PFS))
2620 return true;
2621 } else {
2622 // Otherwise, handle normal operands.
2623 if (parseOptionalParamAttrs(ArgAttrs) || parseValue(ArgTy, V, PFS))
2624 return true;
2625 }
2626 ArgList.push_back(ParamInfo(
2627 ArgLoc, V, AttributeSet::get(V->getContext(), ArgAttrs)));
2628 }
2629
2630 if (IsMustTailCall && InVarArgsFunc)
2631 return tokError("expected '...' at end of argument list for musttail call "
2632 "in varargs function");
2633
2634 Lex.Lex(); // Lex the ')'.
2635 return false;
2636}
2637
2638/// parseRequiredTypeAttr
2639/// ::= attrname(<ty>)
2640bool LLParser::parseRequiredTypeAttr(Type *&Result, lltok::Kind AttrName) {
2641 Result = nullptr;
2642 if (!EatIfPresent(AttrName))
2643 return true;
2644 if (!EatIfPresent(lltok::lparen))
2645 return error(Lex.getLoc(), "expected '('");
2646 if (parseType(Result))
2647 return true;
2648 if (!EatIfPresent(lltok::rparen))
2649 return error(Lex.getLoc(), "expected ')'");
2650 return false;
2651}
2652
2653/// parsePreallocated
2654/// ::= preallocated(<ty>)
2655bool LLParser::parsePreallocated(Type *&Result) {
2656 return parseRequiredTypeAttr(Result, lltok::kw_preallocated);
2657}
2658
2659/// parseByRef
2660/// ::= byref(<type>)
2661bool LLParser::parseByRef(Type *&Result) {
2662 return parseRequiredTypeAttr(Result, lltok::kw_byref);
2663}
2664
2665/// parseOptionalOperandBundles
2666/// ::= /*empty*/
2667/// ::= '[' OperandBundle [, OperandBundle ]* ']'
2668///
2669/// OperandBundle
2670/// ::= bundle-tag '(' ')'
2671/// ::= bundle-tag '(' Type Value [, Type Value ]* ')'
2672///
2673/// bundle-tag ::= String Constant
2674bool LLParser::parseOptionalOperandBundles(
2675 SmallVectorImpl<OperandBundleDef> &BundleList, PerFunctionState &PFS) {
2676 LocTy BeginLoc = Lex.getLoc();
2677 if (!EatIfPresent(lltok::lsquare))
2678 return false;
2679
2680 while (Lex.getKind() != lltok::rsquare) {
2681 // If this isn't the first operand bundle, we need a comma.
2682 if (!BundleList.empty() &&
2683 parseToken(lltok::comma, "expected ',' in input list"))
2684 return true;
2685
2686 std::string Tag;
2687 if (parseStringConstant(Tag))
2688 return true;
2689
2690 if (parseToken(lltok::lparen, "expected '(' in operand bundle"))
2691 return true;
2692
2693 std::vector<Value *> Inputs;
2694 while (Lex.getKind() != lltok::rparen) {
2695 // If this isn't the first input, we need a comma.
2696 if (!Inputs.empty() &&
2697 parseToken(lltok::comma, "expected ',' in input list"))
2698 return true;
2699
2700 Type *Ty = nullptr;
2701 Value *Input = nullptr;
2702 if (parseType(Ty) || parseValue(Ty, Input, PFS))
2703 return true;
2704 Inputs.push_back(Input);
2705 }
2706
2707 BundleList.emplace_back(std::move(Tag), std::move(Inputs));
2708
2709 Lex.Lex(); // Lex the ')'.
2710 }
2711
2712 if (BundleList.empty())
2713 return error(BeginLoc, "operand bundle set must not be empty");
2714
2715 Lex.Lex(); // Lex the ']'.
2716 return false;
2717}
2718
2719/// parseArgumentList - parse the argument list for a function type or function
2720/// prototype.
2721/// ::= '(' ArgTypeListI ')'
2722/// ArgTypeListI
2723/// ::= /*empty*/
2724/// ::= '...'
2725/// ::= ArgTypeList ',' '...'
2726/// ::= ArgType (',' ArgType)*
2727///
2728bool LLParser::parseArgumentList(SmallVectorImpl<ArgInfo> &ArgList,
2729 bool &IsVarArg) {
2730 unsigned CurValID = 0;
2731 IsVarArg = false;
2732 assert(Lex.getKind() == lltok::lparen);
2733 Lex.Lex(); // eat the (.
2734
2735 if (Lex.getKind() == lltok::rparen) {
2736 // empty
2737 } else if (Lex.getKind() == lltok::dotdotdot) {
2738 IsVarArg = true;
2739 Lex.Lex();
2740 } else {
2741 LocTy TypeLoc = Lex.getLoc();
2742 Type *ArgTy = nullptr;
2743 AttrBuilder Attrs;
2744 std::string Name;
2745
2746 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2747 return true;
2748
2749 if (ArgTy->isVoidTy())
2750 return error(TypeLoc, "argument can not have void type");
2751
2752 if (Lex.getKind() == lltok::LocalVar) {
2753 Name = Lex.getStrVal();
2754 Lex.Lex();
2755 } else if (Lex.getKind() == lltok::LocalVarID) {
2756 if (Lex.getUIntVal() != CurValID)
2757 return error(TypeLoc, "argument expected to be numbered '%" +
2758 Twine(CurValID) + "'");
2759 ++CurValID;
2760 Lex.Lex();
2761 }
2762
2763 if (!FunctionType::isValidArgumentType(ArgTy))
2764 return error(TypeLoc, "invalid type for function argument");
2765
2766 ArgList.emplace_back(TypeLoc, ArgTy,
2767 AttributeSet::get(ArgTy->getContext(), Attrs),
2768 std::move(Name));
2769
2770 while (EatIfPresent(lltok::comma)) {
2771 // Handle ... at end of arg list.
2772 if (EatIfPresent(lltok::dotdotdot)) {
2773 IsVarArg = true;
2774 break;
2775 }
2776
2777 // Otherwise must be an argument type.
2778 TypeLoc = Lex.getLoc();
2779 if (parseType(ArgTy) || parseOptionalParamAttrs(Attrs))
2780 return true;
2781
2782 if (ArgTy->isVoidTy())
2783 return error(TypeLoc, "argument can not have void type");
2784
2785 if (Lex.getKind() == lltok::LocalVar) {
2786 Name = Lex.getStrVal();
2787 Lex.Lex();
2788 } else {
2789 if (Lex.getKind() == lltok::LocalVarID) {
2790 if (Lex.getUIntVal() != CurValID)
2791 return error(TypeLoc, "argument expected to be numbered '%" +
2792 Twine(CurValID) + "'");
2793 Lex.Lex();
2794 }
2795 ++CurValID;
2796 Name = "";
2797 }
2798
2799 if (!ArgTy->isFirstClassType())
2800 return error(TypeLoc, "invalid type for function argument");
2801
2802 ArgList.emplace_back(TypeLoc, ArgTy,
2803 AttributeSet::get(ArgTy->getContext(), Attrs),
2804 std::move(Name));
2805 }
2806 }
2807
2808 return parseToken(lltok::rparen, "expected ')' at end of argument list");
2809}
2810
2811/// parseFunctionType
2812/// ::= Type ArgumentList OptionalAttrs
2813bool LLParser::parseFunctionType(Type *&Result) {
2814 assert(Lex.getKind() == lltok::lparen);
2815
2816 if (!FunctionType::isValidReturnType(Result))
2817 return tokError("invalid function return type");
2818
2819 SmallVector<ArgInfo, 8> ArgList;
2820 bool IsVarArg;
2821 if (parseArgumentList(ArgList, IsVarArg))
2822 return true;
2823
2824 // Reject names on the arguments lists.
2825 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2826 if (!ArgList[i].Name.empty())
2827 return error(ArgList[i].Loc, "argument name invalid in function type");
2828 if (ArgList[i].Attrs.hasAttributes())
2829 return error(ArgList[i].Loc,
2830 "argument attributes invalid in function type");
2831 }
2832
2833 SmallVector<Type*, 16> ArgListTy;
2834 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
2835 ArgListTy.push_back(ArgList[i].Ty);
2836
2837 Result = FunctionType::get(Result, ArgListTy, IsVarArg);
2838 return false;
2839}
2840
2841/// parseAnonStructType - parse an anonymous struct type, which is inlined into
2842/// other structs.
2843bool LLParser::parseAnonStructType(Type *&Result, bool Packed) {
2844 SmallVector<Type*, 8> Elts;
2845 if (parseStructBody(Elts))
2846 return true;
2847
2848 Result = StructType::get(Context, Elts, Packed);
2849 return false;
2850}
2851
2852/// parseStructDefinition - parse a struct in a 'type' definition.
2853bool LLParser::parseStructDefinition(SMLoc TypeLoc, StringRef Name,
2854 std::pair<Type *, LocTy> &Entry,
2855 Type *&ResultTy) {
2856 // If the type was already defined, diagnose the redefinition.
2857 if (Entry.first && !Entry.second.isValid())
2858 return error(TypeLoc, "redefinition of type");
2859
2860 // If we have opaque, just return without filling in the definition for the
2861 // struct. This counts as a definition as far as the .ll file goes.
2862 if (EatIfPresent(lltok::kw_opaque)) {
2863 // This type is being defined, so clear the location to indicate this.
2864 Entry.second = SMLoc();
2865
2866 // If this type number has never been uttered, create it.
2867 if (!Entry.first)
2868 Entry.first = StructType::create(Context, Name);
2869 ResultTy = Entry.first;
2870 return false;
2871 }
2872
2873 // If the type starts with '<', then it is either a packed struct or a vector.
2874 bool isPacked = EatIfPresent(lltok::less);
2875
2876 // If we don't have a struct, then we have a random type alias, which we
2877 // accept for compatibility with old files. These types are not allowed to be
2878 // forward referenced and not allowed to be recursive.
2879 if (Lex.getKind() != lltok::lbrace) {
2880 if (Entry.first)
2881 return error(TypeLoc, "forward references to non-struct type");
2882
2883 ResultTy = nullptr;
2884 if (isPacked)
2885 return parseArrayVectorType(ResultTy, true);
2886 return parseType(ResultTy);
2887 }
2888
2889 // This type is being defined, so clear the location to indicate this.
2890 Entry.second = SMLoc();
2891
2892 // If this type number has never been uttered, create it.
2893 if (!Entry.first)
2894 Entry.first = StructType::create(Context, Name);
2895
2896 StructType *STy = cast<StructType>(Entry.first);
2897
2898 SmallVector<Type*, 8> Body;
2899 if (parseStructBody(Body) ||
2900 (isPacked && parseToken(lltok::greater, "expected '>' in packed struct")))
2901 return true;
2902
2903 STy->setBody(Body, isPacked);
2904 ResultTy = STy;
2905 return false;
2906}
2907
2908/// parseStructType: Handles packed and unpacked types. </> parsed elsewhere.
2909/// StructType
2910/// ::= '{' '}'
2911/// ::= '{' Type (',' Type)* '}'
2912/// ::= '<' '{' '}' '>'
2913/// ::= '<' '{' Type (',' Type)* '}' '>'
2914bool LLParser::parseStructBody(SmallVectorImpl<Type *> &Body) {
2915 assert(Lex.getKind() == lltok::lbrace);
2916 Lex.Lex(); // Consume the '{'
2917
2918 // Handle the empty struct.
2919 if (EatIfPresent(lltok::rbrace))
2920 return false;
2921
2922 LocTy EltTyLoc = Lex.getLoc();
2923 Type *Ty = nullptr;
2924 if (parseType(Ty))
2925 return true;
2926 Body.push_back(Ty);
2927
2928 if (!StructType::isValidElementType(Ty))
2929 return error(EltTyLoc, "invalid element type for struct");
2930
2931 while (EatIfPresent(lltok::comma)) {
2932 EltTyLoc = Lex.getLoc();
2933 if (parseType(Ty))
2934 return true;
2935
2936 if (!StructType::isValidElementType(Ty))
2937 return error(EltTyLoc, "invalid element type for struct");
2938
2939 Body.push_back(Ty);
2940 }
2941
2942 return parseToken(lltok::rbrace, "expected '}' at end of struct");
2943}
2944
2945/// parseArrayVectorType - parse an array or vector type, assuming the first
2946/// token has already been consumed.
2947/// Type
2948/// ::= '[' APSINTVAL 'x' Types ']'
2949/// ::= '<' APSINTVAL 'x' Types '>'
2950/// ::= '<' 'vscale' 'x' APSINTVAL 'x' Types '>'
2951bool LLParser::parseArrayVectorType(Type *&Result, bool IsVector) {
2952 bool Scalable = false;
2953
2954 if (IsVector && Lex.getKind() == lltok::kw_vscale) {
2955 Lex.Lex(); // consume the 'vscale'
2956 if (parseToken(lltok::kw_x, "expected 'x' after vscale"))
2957 return true;
2958
2959 Scalable = true;
2960 }
2961
2962 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
2963 Lex.getAPSIntVal().getBitWidth() > 64)
2964 return tokError("expected number in address space");
2965
2966 LocTy SizeLoc = Lex.getLoc();
2967 uint64_t Size = Lex.getAPSIntVal().getZExtValue();
2968 Lex.Lex();
2969
2970 if (parseToken(lltok::kw_x, "expected 'x' after element count"))
2971 return true;
2972
2973 LocTy TypeLoc = Lex.getLoc();
2974 Type *EltTy = nullptr;
2975 if (parseType(EltTy))
2976 return true;
2977
2978 if (parseToken(IsVector ? lltok::greater : lltok::rsquare,
2979 "expected end of sequential type"))
2980 return true;
2981
2982 if (IsVector) {
2983 if (Size == 0)
2984 return error(SizeLoc, "zero element vector is illegal");
2985 if ((unsigned)Size != Size)
2986 return error(SizeLoc, "size too large for vector");
2987 if (!VectorType::isValidElementType(EltTy))
2988 return error(TypeLoc, "invalid vector element type");
2989 Result = VectorType::get(EltTy, unsigned(Size), Scalable);
2990 } else {
2991 if (!ArrayType::isValidElementType(EltTy))
2992 return error(TypeLoc, "invalid array element type");
2993 Result = ArrayType::get(EltTy, Size);
2994 }
2995 return false;
2996}
2997
2998//===----------------------------------------------------------------------===//
2999// Function Semantic Analysis.
3000//===----------------------------------------------------------------------===//
3001
3002LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
3003 int functionNumber)
3004 : P(p), F(f), FunctionNumber(functionNumber) {
3005
3006 // Insert unnamed arguments into the NumberedVals list.
3007 for (Argument &A : F.args())
3008 if (!A.hasName())
3009 NumberedVals.push_back(&A);
3010}
3011
3012LLParser::PerFunctionState::~PerFunctionState() {
3013 // If there were any forward referenced non-basicblock values, delete them.
3014
3015 for (const auto &P : ForwardRefVals) {
3016 if (isa<BasicBlock>(P.second.first))
3017 continue;
3018 P.second.first->replaceAllUsesWith(
3019 UndefValue::get(P.second.first->getType()));
3020 P.second.first->deleteValue();
3021 }
3022
3023 for (const auto &P : ForwardRefValIDs) {
3024 if (isa<BasicBlock>(P.second.first))
3025 continue;
3026 P.second.first->replaceAllUsesWith(
3027 UndefValue::get(P.second.first->getType()));
3028 P.second.first->deleteValue();
3029 }
3030}
3031
3032bool LLParser::PerFunctionState::finishFunction() {
3033 if (!ForwardRefVals.empty())
3034 return P.error(ForwardRefVals.begin()->second.second,
3035 "use of undefined value '%" + ForwardRefVals.begin()->first +
3036 "'");
3037 if (!ForwardRefValIDs.empty())
3038 return P.error(ForwardRefValIDs.begin()->second.second,
3039 "use of undefined value '%" +
3040 Twine(ForwardRefValIDs.begin()->first) + "'");
3041 return false;
3042}
3043
3044/// getVal - Get a value with the specified name or ID, creating a
3045/// forward reference record if needed. This can return null if the value
3046/// exists but does not have the right type.
3047Value *LLParser::PerFunctionState::getVal(const std::string &Name, Type *Ty,
3048 LocTy Loc, bool IsCall) {
3049 // Look this name up in the normal function symbol table.
3050 Value *Val = F.getValueSymbolTable()->lookup(Name);
3051
3052 // If this is a forward reference for the value, see if we already created a
3053 // forward ref record.
3054 if (!Val) {
3055 auto I = ForwardRefVals.find(Name);
3056 if (I != ForwardRefVals.end())
3057 Val = I->second.first;
3058 }
3059
3060 // If we have the value in the symbol table or fwd-ref table, return it.
3061 if (Val)
3062 return P.checkValidVariableType(Loc, "%" + Name, Ty, Val, IsCall);
3063
3064 // Don't make placeholders with invalid type.
3065 if (!Ty->isFirstClassType()) {
3066 P.error(Loc, "invalid use of a non-first-class type");
3067 return nullptr;
3068 }
3069
3070 // Otherwise, create a new forward reference for this value and remember it.
3071 Value *FwdVal;
3072 if (Ty->isLabelTy()) {
3073 FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
3074 } else {
3075 FwdVal = new Argument(Ty, Name);
3076 }
3077
3078 ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
3079 return FwdVal;
3080}
3081
3082Value *LLParser::PerFunctionState::getVal(unsigned ID, Type *Ty, LocTy Loc,
3083 bool IsCall) {
3084 // Look this name up in the normal function symbol table.
3085 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
3086
3087 // If this is a forward reference for the value, see if we already created a
3088 // forward ref record.
3089 if (!Val) {
3090 auto I = ForwardRefValIDs.find(ID);
3091 if (I != ForwardRefValIDs.end())
3092 Val = I->second.first;
3093 }
3094
3095 // If we have the value in the symbol table or fwd-ref table, return it.
3096 if (Val)
3097 return P.checkValidVariableType(Loc, "%" + Twine(ID), Ty, Val, IsCall);
3098
3099 if (!Ty->isFirstClassType()) {
3100 P.error(Loc, "invalid use of a non-first-class type");
3101 return nullptr;
3102 }
3103
3104 // Otherwise, create a new forward reference for this value and remember it.
3105 Value *FwdVal;
3106 if (Ty->isLabelTy()) {
3107 FwdVal = BasicBlock::Create(F.getContext(), "", &F);
3108 } else {
3109 FwdVal = new Argument(Ty);
3110 }
3111
3112 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
3113 return FwdVal;
3114}
3115
3116/// setInstName - After an instruction is parsed and inserted into its
3117/// basic block, this installs its name.
3118bool LLParser::PerFunctionState::setInstName(int NameID,
3119 const std::string &NameStr,
3120 LocTy NameLoc, Instruction *Inst) {
3121 // If this instruction has void type, it cannot have a name or ID specified.
3122 if (Inst->getType()->isVoidTy()) {
3123 if (NameID != -1 || !NameStr.empty())
3124 return P.error(NameLoc, "instructions returning void cannot have a name");
3125 return false;
3126 }
3127
3128 // If this was a numbered instruction, verify that the instruction is the
3129 // expected value and resolve any forward references.
3130 if (NameStr.empty()) {
3131 // If neither a name nor an ID was specified, just use the next ID.
3132 if (NameID == -1)
3133 NameID = NumberedVals.size();
3134
3135 if (unsigned(NameID) != NumberedVals.size())
3136 return P.error(NameLoc, "instruction expected to be numbered '%" +
3137 Twine(NumberedVals.size()) + "'");
3138
3139 auto FI = ForwardRefValIDs.find(NameID);
3140 if (FI != ForwardRefValIDs.end()) {
3141 Value *Sentinel = FI->second.first;
3142 if (Sentinel->getType() != Inst->getType())
3143 return P.error(NameLoc, "instruction forward referenced with type '" +
3144 getTypeString(FI->second.first->getType()) +
3145 "'");
3146
3147 Sentinel->replaceAllUsesWith(Inst);
3148 Sentinel->deleteValue();
3149 ForwardRefValIDs.erase(FI);
3150 }
3151
3152 NumberedVals.push_back(Inst);
3153 return false;
3154 }
3155
3156 // Otherwise, the instruction had a name. Resolve forward refs and set it.
3157 auto FI = ForwardRefVals.find(NameStr);
3158 if (FI != ForwardRefVals.end()) {
3159 Value *Sentinel = FI->second.first;
3160 if (Sentinel->getType() != Inst->getType())
3161 return P.error(NameLoc, "instruction forward referenced with type '" +
3162 getTypeString(FI->second.first->getType()) +
3163 "'");
3164
3165 Sentinel->replaceAllUsesWith(Inst);
3166 Sentinel->deleteValue();
3167 ForwardRefVals.erase(FI);
3168 }
3169
3170 // Set the name on the instruction.
3171 Inst->setName(NameStr);
3172
3173 if (Inst->getName() != NameStr)
3174 return P.error(NameLoc, "multiple definition of local value named '" +
3175 NameStr + "'");
3176 return false;
3177}
3178
3179/// getBB - Get a basic block with the specified name or ID, creating a
3180/// forward reference record if needed.
3181BasicBlock *LLParser::PerFunctionState::getBB(const std::string &Name,
3182 LocTy Loc) {
3183 return dyn_cast_or_null<BasicBlock>(
3184 getVal(Name, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
3185}
3186
3187BasicBlock *LLParser::PerFunctionState::getBB(unsigned ID, LocTy Loc) {
3188 return dyn_cast_or_null<BasicBlock>(
3189 getVal(ID, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
3190}
3191
3192/// defineBB - Define the specified basic block, which is either named or
3193/// unnamed. If there is an error, this returns null otherwise it returns
3194/// the block being defined.
3195BasicBlock *LLParser::PerFunctionState::defineBB(const std::string &Name,
3196 int NameID, LocTy Loc) {
3197 BasicBlock *BB;
3198 if (Name.empty()) {
3199 if (NameID != -1 && unsigned(NameID) != NumberedVals.size()) {
3200 P.error(Loc, "label expected to be numbered '" +
3201 Twine(NumberedVals.size()) + "'");
3202 return nullptr;
3203 }
3204 BB = getBB(NumberedVals.size(), Loc);
3205 if (!BB) {
3206 P.error(Loc, "unable to create block numbered '" +
3207 Twine(NumberedVals.size()) + "'");
3208 return nullptr;
3209 }
3210 } else {
3211 BB = getBB(Name, Loc);
3212 if (!BB) {
3213 P.error(Loc, "unable to create block named '" + Name + "'");
3214 return nullptr;
3215 }
3216 }
3217
3218 // Move the block to the end of the function. Forward ref'd blocks are
3219 // inserted wherever they happen to be referenced.
3220 F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
3221
3222 // Remove the block from forward ref sets.
3223 if (Name.empty()) {
3224 ForwardRefValIDs.erase(NumberedVals.size());
3225 NumberedVals.push_back(BB);
3226 } else {
3227 // BB forward references are already in the function symbol table.
3228 ForwardRefVals.erase(Name);
3229 }
3230
3231 return BB;
3232}
3233
3234//===----------------------------------------------------------------------===//
3235// Constants.
3236//===----------------------------------------------------------------------===//
3237
3238/// parseValID - parse an abstract value that doesn't necessarily have a
3239/// type implied. For example, if we parse "4" we don't know what integer type
3240/// it has. The value will later be combined with its type and checked for
3241/// sanity. PFS is used to convert function-local operands of metadata (since
3242/// metadata operands are not just parsed here but also converted to values).
3243/// PFS can be null when we are not parsing metadata values inside a function.
3244bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS) {
3245 ID.Loc = Lex.getLoc();
3246 switch (Lex.getKind()) {
3247 default:
3248 return tokError("expected value token");
3249 case lltok::GlobalID: // @42
3250 ID.UIntVal = Lex.getUIntVal();
3251 ID.Kind = ValID::t_GlobalID;
3252 break;
3253 case lltok::GlobalVar: // @foo
3254 ID.StrVal = Lex.getStrVal();
3255 ID.Kind = ValID::t_GlobalName;
3256 break;
3257 case lltok::LocalVarID: // %42
3258 ID.UIntVal = Lex.getUIntVal();
3259 ID.Kind = ValID::t_LocalID;
3260 break;
3261 case lltok::LocalVar: // %foo
3262 ID.StrVal = Lex.getStrVal();
3263 ID.Kind = ValID::t_LocalName;
3264 break;
3265 case lltok::APSInt:
3266 ID.APSIntVal = Lex.getAPSIntVal();
3267 ID.Kind = ValID::t_APSInt;
3268 break;
3269 case lltok::APFloat:
3270 ID.APFloatVal = Lex.getAPFloatVal();
3271 ID.Kind = ValID::t_APFloat;
3272 break;
3273 case lltok::kw_true:
3274 ID.ConstantVal = ConstantInt::getTrue(Context);
3275 ID.Kind = ValID::t_Constant;
3276 break;
3277 case lltok::kw_false:
3278 ID.ConstantVal = ConstantInt::getFalse(Context);
3279 ID.Kind = ValID::t_Constant;
3280 break;
3281 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
3282 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
3283 case lltok::kw_poison: ID.Kind = ValID::t_Poison; break;
3284 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
3285 case lltok::kw_none: ID.Kind = ValID::t_None; break;
3286
3287 case lltok::lbrace: {
3288 // ValID ::= '{' ConstVector '}'
3289 Lex.Lex();
3290 SmallVector<Constant*, 16> Elts;
3291 if (parseGlobalValueVector(Elts) ||
3292 parseToken(lltok::rbrace, "expected end of struct constant"))
3293 return true;
3294
3295 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.size());
3296 ID.UIntVal = Elts.size();
3297 memcpy(ID.ConstantStructElts.get(), Elts.data(),
3298 Elts.size() * sizeof(Elts[0]));
3299 ID.Kind = ValID::t_ConstantStruct;
3300 return false;
3301 }
3302 case lltok::less: {
3303 // ValID ::= '<' ConstVector '>' --> Vector.
3304 // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
3305 Lex.Lex();
3306 bool isPackedStruct = EatIfPresent(lltok::lbrace);
3307
3308 SmallVector<Constant*, 16> Elts;
3309 LocTy FirstEltLoc = Lex.getLoc();
3310 if (parseGlobalValueVector(Elts) ||
3311 (isPackedStruct &&
3312 parseToken(lltok::rbrace, "expected end of packed struct")) ||
3313 parseToken(lltok::greater, "expected end of constant"))
3314 return true;
3315
3316 if (isPackedStruct) {
3317 ID.ConstantStructElts = std::make_unique<Constant *[]>(Elts.size());
3318 memcpy(ID.ConstantStructElts.get(), Elts.data(),
3319 Elts.size() * sizeof(Elts[0]));
3320 ID.UIntVal = Elts.size();
3321 ID.Kind = ValID::t_PackedConstantStruct;
3322 return false;
3323 }
3324
3325 if (Elts.empty())
3326 return error(ID.Loc, "constant vector must not be empty");
3327
3328 if (!Elts[0]->getType()->isIntegerTy() &&
3329 !Elts[0]->getType()->isFloatingPointTy() &&
3330 !Elts[0]->getType()->isPointerTy())
3331 return error(
3332 FirstEltLoc,
3333 "vector elements must have integer, pointer or floating point type");
3334
3335 // Verify that all the vector elements have the same type.
3336 for (unsigned i = 1, e = Elts.size(); i != e; ++i)
3337 if (Elts[i]->getType() != Elts[0]->getType())
3338 return error(FirstEltLoc, "vector element #" + Twine(i) +
3339 " is not of type '" +
3340 getTypeString(Elts[0]->getType()));
3341
3342 ID.ConstantVal = ConstantVector::get(Elts);
3343 ID.Kind = ValID::t_Constant;
3344 return false;
3345 }
3346 case lltok::lsquare: { // Array Constant
3347 Lex.Lex();
3348 SmallVector<Constant*, 16> Elts;
3349 LocTy FirstEltLoc = Lex.getLoc();
3350 if (parseGlobalValueVector(Elts) ||
3351 parseToken(lltok::rsquare, "expected end of array constant"))
3352 return true;
3353
3354 // Handle empty element.
3355 if (Elts.empty()) {
3356 // Use undef instead of an array because it's inconvenient to determine
3357 // the element type at this point, there being no elements to examine.
3358 ID.Kind = ValID::t_EmptyArray;
3359 return false;
3360 }
3361
3362 if (!Elts[0]->getType()->isFirstClassType())
3363 return error(FirstEltLoc, "invalid array element type: " +
3364 getTypeString(Elts[0]->getType()));
3365
3366 ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
3367
3368 // Verify all elements are correct type!
3369 for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
3370 if (Elts[i]->getType() != Elts[0]->getType())
3371 return error(FirstEltLoc, "array element #" + Twine(i) +
3372 " is not of type '" +
3373 getTypeString(Elts[0]->getType()));
3374 }
3375
3376 ID.ConstantVal = ConstantArray::get(ATy, Elts);
3377 ID.Kind = ValID::t_Constant;
3378 return false;
3379 }
3380 case lltok::kw_c: // c "foo"
3381 Lex.Lex();
3382 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
3383 false);
3384 if (parseToken(lltok::StringConstant, "expected string"))
3385 return true;
3386 ID.Kind = ValID::t_Constant;
3387 return false;
3388
3389 case lltok::kw_asm: {
3390 // ValID ::= 'asm' SideEffect? AlignStack? IntelDialect? STRINGCONSTANT ','
3391 // STRINGCONSTANT
3392 bool HasSideEffect, AlignStack, AsmDialect;
3393 Lex.Lex();
3394 if (parseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
3395 parseOptionalToken(lltok::kw_alignstack, AlignStack) ||
3396 parseOptionalToken(lltok::kw_inteldialect, AsmDialect) ||
3397 parseStringConstant(ID.StrVal) ||
3398 parseToken(lltok::comma, "expected comma in inline asm expression") ||
3399 parseToken(lltok::StringConstant, "expected constraint string"))
3400 return true;
3401 ID.StrVal2 = Lex.getStrVal();
3402 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
3403 (unsigned(AsmDialect)<<2);
3404 ID.Kind = ValID::t_InlineAsm;
3405 return false;
3406 }
3407
3408 case lltok::kw_blockaddress: {
3409 // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
3410 Lex.Lex();
3411
3412 ValID Fn, Label;
3413
3414 if (parseToken(lltok::lparen, "expected '(' in block address expression") ||
3415 parseValID(Fn) ||
3416 parseToken(lltok::comma,
3417 "expected comma in block address expression") ||
3418 parseValID(Label) ||
3419 parseToken(lltok::rparen, "expected ')' in block address expression"))
3420 return true;
3421
3422 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
3423 return error(Fn.Loc, "expected function name in blockaddress");
3424 if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
3425 return error(Label.Loc, "expected basic block name in blockaddress");
3426
3427 // Try to find the function (but skip it if it's forward-referenced).
3428 GlobalValue *GV = nullptr;
3429 if (Fn.Kind == ValID::t_GlobalID) {
3430 if (Fn.UIntVal < NumberedVals.size())
3431 GV = NumberedVals[Fn.UIntVal];
3432 } else if (!ForwardRefVals.count(Fn.StrVal)) {
3433 GV = M->getNamedValue(Fn.StrVal);
3434 }
3435 Function *F = nullptr;
3436 if (GV) {
3437 // Confirm that it's actually a function with a definition.
3438 if (!isa<Function>(GV))
3439 return error(Fn.Loc, "expected function name in blockaddress");
3440 F = cast<Function>(GV);
3441 if (F->isDeclaration())
3442 return error(Fn.Loc, "cannot take blockaddress inside a declaration");
3443 }
3444
3445 if (!F) {
3446 // Make a global variable as a placeholder for this reference.
3447 GlobalValue *&FwdRef =
3448 ForwardRefBlockAddresses.insert(std::make_pair(
3449 std::move(Fn),
3450 std::map<ValID, GlobalValue *>()))
3451 .first->second.insert(std::make_pair(std::move(Label), nullptr))
3452 .first->second;
3453 if (!FwdRef)
3454 FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
3455 GlobalValue::InternalLinkage, nullptr, "");
3456 ID.ConstantVal = FwdRef;
3457 ID.Kind = ValID::t_Constant;
3458 return false;
3459 }
3460
3461 // We found the function; now find the basic block. Don't use PFS, since we
3462 // might be inside a constant expression.
3463 BasicBlock *BB;
3464 if (BlockAddressPFS && F == &BlockAddressPFS->getFunction()) {
3465 if (Label.Kind == ValID::t_LocalID)
3466 BB = BlockAddressPFS->getBB(Label.UIntVal, Label.Loc);
3467 else
3468 BB = BlockAddressPFS->getBB(Label.StrVal, Label.Loc);
3469 if (!BB)
3470 return error(Label.Loc, "referenced value is not a basic block");
3471 } else {
3472 if (Label.Kind == ValID::t_LocalID)
3473 return error(Label.Loc, "cannot take address of numeric label after "
3474 "the function is defined");
3475 BB = dyn_cast_or_null<BasicBlock>(
3476 F->getValueSymbolTable()->lookup(Label.StrVal));
3477 if (!BB)
3478 return error(Label.Loc, "referenced value is not a basic block");
3479 }
3480
3481 ID.ConstantVal = BlockAddress::get(F, BB);
3482 ID.Kind = ValID::t_Constant;
3483 return false;
3484 }
3485
3486 case lltok::kw_dso_local_equivalent: {
3487 // ValID ::= 'dso_local_equivalent' @foo
3488 Lex.Lex();
3489
3490 ValID Fn;
3491
3492 if (parseValID(Fn))
3493 return true;
3494
3495 if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
3496 return error(Fn.Loc,
3497 "expected global value name in dso_local_equivalent");
3498
3499 // Try to find the function (but skip it if it's forward-referenced).
3500 GlobalValue *GV = nullptr;
3501 if (Fn.Kind == ValID::t_GlobalID) {
3502 if (Fn.UIntVal < NumberedVals.size())
3503 GV = NumberedVals[Fn.UIntVal];
3504 } else if (!ForwardRefVals.count(Fn.StrVal)) {
3505 GV = M->getNamedValue(Fn.StrVal);
3506 }
3507
3508 assert(GV && "Could not find a corresponding global variable");
3509
3510 if (!GV->getValueType()->isFunctionTy())
3511 return error(Fn.Loc, "expected a function, alias to function, or ifunc "
3512 "in dso_local_equivalent");
3513
3514 ID.ConstantVal = DSOLocalEquivalent::get(GV);
3515 ID.Kind = ValID::t_Constant;
3516 return false;
3517 }
3518
3519 case lltok::kw_trunc:
3520 case lltok::kw_zext:
3521 case lltok::kw_sext:
3522 case lltok::kw_fptrunc:
3523 case lltok::kw_fpext:
3524 case lltok::kw_bitcast:
3525 case lltok::kw_addrspacecast:
3526 case lltok::kw_uitofp:
3527 case lltok::kw_sitofp:
3528 case lltok::kw_fptoui:
3529 case lltok::kw_fptosi:
3530 case lltok::kw_inttoptr:
3531 case lltok::kw_ptrtoint: {
3532 unsigned Opc = Lex.getUIntVal();
3533 Type *DestTy = nullptr;
3534 Constant *SrcVal;
3535 Lex.Lex();
3536 if (parseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
3537 parseGlobalTypeAndValue(SrcVal) ||
3538 parseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
3539 parseType(DestTy) ||
3540 parseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
3541 return true;
3542 if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
3543 return error(ID.Loc, "invalid cast opcode for cast from '" +
3544 getTypeString(SrcVal->getType()) + "' to '" +
3545 getTypeString(DestTy) + "'");
3546 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
3547 SrcVal, DestTy);
3548 ID.Kind = ValID::t_Constant;
3549 return false;
3550 }
3551 case lltok::kw_extractvalue: {
3552 Lex.Lex();
3553 Constant *Val;
3554 SmallVector<unsigned, 4> Indices;
3555 if (parseToken(lltok::lparen,
3556 "expected '(' in extractvalue constantexpr") ||
3557 parseGlobalTypeAndValue(Val) || parseIndexList(Indices) ||
3558 parseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
3559 return true;
3560
3561 if (!Val->getType()->isAggregateType())
3562 return error(ID.Loc, "extractvalue operand must be aggregate type");
3563 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
3564 return error(ID.Loc, "invalid indices for extractvalue");
3565 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
3566 ID.Kind = ValID::t_Constant;
3567 return false;
3568 }
3569 case lltok::kw_insertvalue: {
3570 Lex.Lex();
3571 Constant *Val0, *Val1;
3572 SmallVector<unsigned, 4> Indices;
3573 if (parseToken(lltok::lparen, "expected '(' in insertvalue constantexpr") ||
3574 parseGlobalTypeAndValue(Val0) ||
3575 parseToken(lltok::comma,
3576 "expected comma in insertvalue constantexpr") ||
3577 parseGlobalTypeAndValue(Val1) || parseIndexList(Indices) ||
3578 parseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
3579 return true;
3580 if (!Val0->getType()->isAggregateType())
3581 return error(ID.Loc, "insertvalue operand must be aggregate type");
3582 Type *IndexedType =
3583 ExtractValueInst::getIndexedType(Val0->getType(), Indices);
3584 if (!IndexedType)
3585 return error(ID.Loc, "invalid indices for insertvalue");
3586 if (IndexedType != Val1->getType())
3587 return error(ID.Loc, "insertvalue operand and field disagree in type: '" +
3588 getTypeString(Val1->getType()) +
3589 "' instead of '" + getTypeString(IndexedType) +
3590 "'");
3591 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
3592 ID.Kind = ValID::t_Constant;
3593 return false;
3594 }
3595 case lltok::kw_icmp:
3596 case lltok::kw_fcmp: {
3597 unsigned PredVal, Opc = Lex.getUIntVal();
3598 Constant *Val0, *Val1;
3599 Lex.Lex();
3600 if (parseCmpPredicate(PredVal, Opc) ||
3601 parseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
3602 parseGlobalTypeAndValue(Val0) ||
3603 parseToken(lltok::comma, "expected comma in compare constantexpr") ||
3604 parseGlobalTypeAndValue(Val1) ||
3605 parseToken(lltok::rparen, "expected ')' in compare constantexpr"))
3606 return true;
3607
3608 if (Val0->getType() != Val1->getType())
3609 return error(ID.Loc, "compare operands must have the same type");
3610
3611 CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
3612
3613 if (Opc == Instruction::FCmp) {
3614 if (!Val0->getType()->isFPOrFPVectorTy())
3615 return error(ID.Loc, "fcmp requires floating point operands");
3616 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
3617 } else {
3618 assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
3619 if (!Val0->getType()->isIntOrIntVectorTy() &&
3620 !Val0->getType()->isPtrOrPtrVectorTy())
3621 return error(ID.Loc, "icmp requires pointer or integer operands");
3622 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
3623 }
3624 ID.Kind = ValID::t_Constant;
3625 return false;
3626 }
3627
3628 // Unary Operators.
3629 case lltok::kw_fneg: {
3630 unsigned Opc = Lex.getUIntVal();
3631 Constant *Val;
3632 Lex.Lex();
3633 if (parseToken(lltok::lparen, "expected '(' in unary constantexpr") ||
3634 parseGlobalTypeAndValue(Val) ||
3635 parseToken(lltok::rparen, "expected ')' in unary constantexpr"))
3636 return true;
3637
3638 // Check that the type is valid for the operator.
3639 switch (Opc) {
3640 case Instruction::FNeg:
3641 if (!Val->getType()->isFPOrFPVectorTy())
3642 return error(ID.Loc, "constexpr requires fp operands");
3643 break;
3644 default: llvm_unreachable("Unknown unary operator!");
3645 }
3646 unsigned Flags = 0;
3647 Constant *C = ConstantExpr::get(Opc, Val, Flags);
3648 ID.ConstantVal = C;
3649 ID.Kind = ValID::t_Constant;
3650 return false;
3651 }
3652 // Binary Operators.
3653 case lltok::kw_add:
3654 case lltok::kw_fadd:
3655 case lltok::kw_sub:
3656 case lltok::kw_fsub:
3657 case lltok::kw_mul:
3658 case lltok::kw_fmul:
3659 case lltok::kw_udiv:
3660 case lltok::kw_sdiv:
3661 case lltok::kw_fdiv:
3662 case lltok::kw_urem:
3663 case lltok::kw_srem:
3664 case lltok::kw_frem:
3665 case lltok::kw_shl:
3666 case lltok::kw_lshr:
3667 case lltok::kw_ashr: {
3668 bool NUW = false;
3669 bool NSW = false;
3670 bool Exact = false;
3671 unsigned Opc = Lex.getUIntVal();
3672 Constant *Val0, *Val1;
3673 Lex.Lex();
3674 if (Opc == Instruction::Add || Opc == Instruction::Sub ||
3675 Opc == Instruction::Mul || Opc == Instruction::Shl) {
3676 if (EatIfPresent(lltok::kw_nuw))
3677 NUW = true;
3678 if (EatIfPresent(lltok::kw_nsw)) {
3679 NSW = true;
3680 if (EatIfPresent(lltok::kw_nuw))
3681 NUW = true;
3682 }
3683 } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
3684 Opc == Instruction::LShr || Opc == Instruction::AShr) {
3685 if (EatIfPresent(lltok::kw_exact))
3686 Exact = true;
3687 }
3688 if (parseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
3689 parseGlobalTypeAndValue(Val0) ||
3690 parseToken(lltok::comma, "expected comma in binary constantexpr") ||
3691 parseGlobalTypeAndValue(Val1) ||
3692 parseToken(lltok::rparen, "expected ')' in binary constantexpr"))
3693 return true;
3694 if (Val0->getType() != Val1->getType())
3695 return error(ID.Loc, "operands of constexpr must have same type");
3696 // Check that the type is valid for the operator.
3697 switch (Opc) {
3698 case Instruction::Add:
3699 case Instruction::Sub:
3700 case Instruction::Mul:
3701 case Instruction::UDiv:
3702 case Instruction::SDiv:
3703 case Instruction::URem:
3704 case Instruction::SRem:
3705 case Instruction::Shl:
3706 case Instruction::AShr:
3707 case Instruction::LShr:
3708 if (!Val0->getType()->isIntOrIntVectorTy())
3709 return error(ID.Loc, "constexpr requires integer operands");
3710 break;
3711 case Instruction::FAdd:
3712 case Instruction::FSub:
3713 case Instruction::FMul:
3714 case Instruction::FDiv:
3715 case Instruction::FRem:
3716 if (!Val0->getType()->isFPOrFPVectorTy())
3717 return error(ID.Loc, "constexpr requires fp operands");
3718 break;
3719 default: llvm_unreachable("Unknown binary operator!");
3720 }
3721 unsigned Flags = 0;
3722 if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
3723 if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap;
3724 if (Exact) Flags |= PossiblyExactOperator::IsExact;
3725 Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
3726 ID.ConstantVal = C;
3727 ID.Kind = ValID::t_Constant;
3728 return false;
3729 }
3730
3731 // Logical Operations
3732 case lltok::kw_and:
3733 case lltok::kw_or:
3734 case lltok::kw_xor: {
3735 unsigned Opc = Lex.getUIntVal();
3736 Constant *Val0, *Val1;
3737 Lex.Lex();
3738 if (parseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
3739 parseGlobalTypeAndValue(Val0) ||
3740 parseToken(lltok::comma, "expected comma in logical constantexpr") ||
3741 parseGlobalTypeAndValue(Val1) ||
3742 parseToken(lltok::rparen, "expected ')' in logical constantexpr"))
3743 return true;
3744 if (Val0->getType() != Val1->getType())
3745 return error(ID.Loc, "operands of constexpr must have same type");
3746 if (!Val0->getType()->isIntOrIntVectorTy())
3747 return error(ID.Loc,
3748 "constexpr requires integer or integer vector operands");
3749 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
3750 ID.Kind = ValID::t_Constant;
3751 return false;
3752 }
3753
3754 case lltok::kw_getelementptr:
3755 case lltok::kw_shufflevector:
3756 case lltok::kw_insertelement:
3757 case lltok::kw_extractelement:
3758 case lltok::kw_select: {
3759 unsigned Opc = Lex.getUIntVal();
3760 SmallVector<Constant*, 16> Elts;
3761 bool InBounds = false;
3762 Type *Ty;
3763 Lex.Lex();
3764
3765 if (Opc == Instruction::GetElementPtr)
3766 InBounds = EatIfPresent(lltok::kw_inbounds);
3767
3768 if (parseToken(lltok::lparen, "expected '(' in constantexpr"))
3769 return true;
3770
3771 LocTy ExplicitTypeLoc = Lex.getLoc();
3772 if (Opc == Instruction::GetElementPtr) {
3773 if (parseType(Ty) ||
3774 parseToken(lltok::comma, "expected comma after getelementptr's type"))
3775 return true;
3776 }
3777
3778 Optional<unsigned> InRangeOp;
3779 if (parseGlobalValueVector(
3780 Elts, Opc == Instruction::GetElementPtr ? &InRangeOp : nullptr) ||
3781 parseToken(lltok::rparen, "expected ')' in constantexpr"))
3782 return true;
3783
3784 if (Opc == Instruction::GetElementPtr) {
3785 if (Elts.size() == 0 ||
3786 !Elts[0]->getType()->isPtrOrPtrVectorTy())
3787 return error(ID.Loc, "base of getelementptr must be a pointer");
3788
3789 Type *BaseType = Elts[0]->getType();
3790 auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
3791 if (Ty != BasePointerType->getElementType())
3792 return error(
3793 ExplicitTypeLoc,
3794 "explicit pointee type doesn't match operand's pointee type");
3795
3796 unsigned GEPWidth =
3797 BaseType->isVectorTy()
3798 ? cast<FixedVectorType>(BaseType)->getNumElements()
3799 : 0;
3800
3801 ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
3802 for (Constant *Val : Indices) {
3803 Type *ValTy = Val->getType();
3804 if (!ValTy->isIntOrIntVectorTy())
3805 return error(ID.Loc, "getelementptr index must be an integer");
3806 if (auto *ValVTy = dyn_cast<VectorType>(ValTy)) {
3807 unsigned ValNumEl = cast<FixedVectorType>(ValVTy)->getNumElements();
3808 if (GEPWidth && (ValNumEl != GEPWidth))
3809 return error(
3810 ID.Loc,
3811 "getelementptr vector index has a wrong number of elements");
3812 // GEPWidth may have been unknown because the base is a scalar,
3813 // but it is known now.
3814 GEPWidth = ValNumEl;
3815 }
3816 }
3817
3818 SmallPtrSet<Type*, 4> Visited;
3819 if (!Indices.empty() && !Ty->isSized(&Visited))
3820 return error(ID.Loc, "base element of getelementptr must be sized");
3821
3822 if (!GetElementPtrInst::getIndexedType(Ty, Indices))
3823 return error(ID.Loc, "invalid getelementptr indices");
3824
3825 if (InRangeOp) {
3826 if (*InRangeOp == 0)
3827 return error(ID.Loc,
3828 "inrange keyword may not appear on pointer operand");
3829 --*InRangeOp;
3830 }
3831
3832 ID.ConstantVal = ConstantExpr::getGetElementPtr(Ty, Elts[0], Indices,
3833 InBounds, InRangeOp);
3834 } else if (Opc == Instruction::Select) {
3835 if (Elts.size() != 3)
3836 return error(ID.Loc, "expected three operands to select");
3837 if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
3838 Elts[2]))
3839 return error(ID.Loc, Reason);
3840 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
3841 } else if (Opc == Instruction::ShuffleVector) {
3842 if (Elts.size() != 3)
3843 return error(ID.Loc, "expected three operands to shufflevector");
3844 if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3845 return error(ID.Loc, "invalid operands to shufflevector");
3846 SmallVector<int, 16> Mask;
3847 ShuffleVectorInst::getShuffleMask(cast<Constant>(Elts[2]), Mask);
3848 ID.ConstantVal = ConstantExpr::getShuffleVector(Elts[0], Elts[1], Mask);
3849 } else if (Opc == Instruction::ExtractElement) {
3850 if (Elts.size() != 2)
3851 return error(ID.Loc, "expected two operands to extractelement");
3852 if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
3853 return error(ID.Loc, "invalid extractelement operands");
3854 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
3855 } else {
3856 assert(Opc == Instruction::InsertElement && "Unknown opcode");
3857 if (Elts.size() != 3)
3858 return error(ID.Loc, "expected three operands to insertelement");
3859 if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
3860 return error(ID.Loc, "invalid insertelement operands");
3861 ID.ConstantVal =
3862 ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
3863 }
3864
3865 ID.Kind = ValID::t_Constant;
3866 return false;
3867 }
3868 }
3869
3870 Lex.Lex();
3871 return false;
3872}
3873
3874/// parseGlobalValue - parse a global value with the specified type.
3875bool LLParser::parseGlobalValue(Type *Ty, Constant *&C) {
3876 C = nullptr;
3877 ValID ID;
3878 Value *V = nullptr;
3879 bool Parsed = parseValID(ID) ||
3880 convertValIDToValue(Ty, ID, V, nullptr, /*IsCall=*/false);
3881 if (V && !(C = dyn_cast<Constant>(V)))
3882 return error(ID.Loc, "global values must be constants");
3883 return Parsed;
3884}
3885
3886bool LLParser::parseGlobalTypeAndValue(Constant *&V) {
3887 Type *Ty = nullptr;
3888 return parseType(Ty) || parseGlobalValue(Ty, V);
3889}
3890
3891bool LLParser::parseOptionalComdat(StringRef GlobalName, Comdat *&C) {
3892 C = nullptr;
3893
3894 LocTy KwLoc = Lex.getLoc();
3895 if (!EatIfPresent(lltok::kw_comdat))
3896 return false;
3897
3898 if (EatIfPresent(lltok::lparen)) {
3899 if (Lex.getKind() != lltok::ComdatVar)
3900 return tokError("expected comdat variable");
3901 C = getComdat(Lex.getStrVal(), Lex.getLoc());
3902 Lex.Lex();
3903 if (parseToken(lltok::rparen, "expected ')' after comdat var"))
3904 return true;
3905 } else {
3906 if (GlobalName.empty())
3907 return tokError("comdat cannot be unnamed");
3908 C = getComdat(std::string(GlobalName), KwLoc);
3909 }
3910
3911 return false;
3912}
3913
3914/// parseGlobalValueVector
3915/// ::= /*empty*/
3916/// ::= [inrange] TypeAndValue (',' [inrange] TypeAndValue)*
3917bool LLParser::parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
3918 Optional<unsigned> *InRangeOp) {
3919 // Empty list.
3920 if (Lex.getKind() == lltok::rbrace ||
3921 Lex.getKind() == lltok::rsquare ||
3922 Lex.getKind() == lltok::greater ||
3923 Lex.getKind() == lltok::rparen)
3924 return false;
3925
3926 do {
3927 if (InRangeOp && !*InRangeOp && EatIfPresent(lltok::kw_inrange))
3928 *InRangeOp = Elts.size();
3929
3930 Constant *C;
3931 if (parseGlobalTypeAndValue(C))
3932 return true;
3933 Elts.push_back(C);
3934 } while (EatIfPresent(lltok::comma));
3935
3936 return false;
3937}
3938
3939bool LLParser::parseMDTuple(MDNode *&MD, bool IsDistinct) {
3940 SmallVector<Metadata *, 16> Elts;
3941 if (parseMDNodeVector(Elts))
3942 return true;
3943
3944 MD = (IsDistinct ? MDTuple::getDistinct : MDTuple::get)(Context, Elts);
3945 return false;
3946}
3947
3948/// MDNode:
3949/// ::= !{ ... }
3950/// ::= !7
3951/// ::= !DILocation(...)
3952bool LLParser::parseMDNode(MDNode *&N) {
3953 if (Lex.getKind() == lltok::MetadataVar)
3954 return parseSpecializedMDNode(N);
3955
3956 return parseToken(lltok::exclaim, "expected '!' here") || parseMDNodeTail(N);
3957}
3958
3959bool LLParser::parseMDNodeTail(MDNode *&N) {
3960 // !{ ... }
3961 if (Lex.getKind() == lltok::lbrace)
3962 return parseMDTuple(N);
3963
3964 // !42
3965 return parseMDNodeID(N);
3966}
3967
3968namespace {
3969
3970/// Structure to represent an optional metadata field.
3971template <class FieldTy> struct MDFieldImpl {
3972 typedef MDFieldImpl ImplTy;
3973 FieldTy Val;
3974 bool Seen;
3975
3976 void assign(FieldTy Val) {
3977 Seen = true;
3978 this->Val = std::move(Val);
3979 }
3980
3981 explicit MDFieldImpl(FieldTy Default)
3982 : Val(std::move(Default)), Seen(false) {}
3983};
3984
3985/// Structure to represent an optional metadata field that
3986/// can be of either type (A or B) and encapsulates the
3987/// MD<typeofA>Field and MD<typeofB>Field structs, so not
3988/// to reimplement the specifics for representing each Field.
3989template <class FieldTypeA, class FieldTypeB> struct MDEitherFieldImpl {
3990 typedef MDEitherFieldImpl<FieldTypeA, FieldTypeB> ImplTy;
3991 FieldTypeA A;
3992 FieldTypeB B;
3993 bool Seen;
3994
3995 enum {
3996 IsInvalid = 0,
3997 IsTypeA = 1,
3998 IsTypeB = 2
3999 } WhatIs;
4000
4001 void assign(FieldTypeA A) {
4002 Seen = true;
4003 this->A = std::move(A);
4004 WhatIs = IsTypeA;
4005 }
4006
4007 void assign(FieldTypeB B) {
4008 Seen = true;
4009 this->B = std::move(B);
4010 WhatIs = IsTypeB;
4011 }
4012
4013 explicit MDEitherFieldImpl(FieldTypeA DefaultA, FieldTypeB DefaultB)
4014 : A(std::move(DefaultA)), B(std::move(DefaultB)), Seen(false),
4015 WhatIs(IsInvalid) {}
4016};
4017
4018struct MDUnsignedField : public MDFieldImpl<uint64_t> {
4019 uint64_t Max;
4020
4021 MDUnsignedField(uint64_t Default = 0, uint64_t Max = UINT64_MAX)
4022 : ImplTy(Default), Max(Max) {}
4023};
4024
4025struct LineField : public MDUnsignedField {
4026 LineField() : MDUnsignedField(0, UINT32_MAX) {}
4027};
4028
4029struct ColumnField : public MDUnsignedField {
4030 ColumnField() : MDUnsignedField(0, UINT16_MAX) {}
4031};
4032
4033struct DwarfTagField : public MDUnsignedField {
4034 DwarfTagField() : MDUnsignedField(0, dwarf::DW_TAG_hi_user) {}
4035 DwarfTagField(dwarf::Tag DefaultTag)
4036 : MDUnsignedField(DefaultTag, dwarf::DW_TAG_hi_user) {}
4037};
4038
4039struct DwarfMacinfoTypeField : public MDUnsignedField {
4040 DwarfMacinfoTypeField() : MDUnsignedField(0, dwarf::DW_MACINFO_vendor_ext) {}
4041 DwarfMacinfoTypeField(dwarf::MacinfoRecordType DefaultType)
4042 : MDUnsignedField(DefaultType, dwarf::DW_MACINFO_vendor_ext) {}
4043};
4044
4045struct DwarfAttEncodingField : public MDUnsignedField {
4046 DwarfAttEncodingField() : MDUnsignedField(0, dwarf::DW_ATE_hi_user) {}
4047};
4048
4049struct DwarfVirtualityField : public MDUnsignedField {
4050 DwarfVirtualityField() : MDUnsignedField(0, dwarf::DW_VIRTUALITY_max) {}
4051};
4052
4053struct DwarfLangField : public MDUnsignedField {
4054 DwarfLangField() : MDUnsignedField(0, dwarf::DW_LANG_hi_user) {}
4055};
4056
4057struct DwarfCCField : public MDUnsignedField {
4058 DwarfCCField() : MDUnsignedField(0, dwarf::DW_CC_hi_user) {}
4059};
4060
4061struct EmissionKindField : public MDUnsignedField {
4062 EmissionKindField() : MDUnsignedField(0, DICompileUnit::LastEmissionKind) {}
4063};
4064
4065struct NameTableKindField : public MDUnsignedField {
4066 NameTableKindField()
4067 : MDUnsignedField(
4068 0, (unsigned)
4069 DICompileUnit::DebugNameTableKind::LastDebugNameTableKind) {}
4070};
4071
4072struct DIFlagField : public MDFieldImpl<DINode::DIFlags> {
4073 DIFlagField() : MDFieldImpl(DINode::FlagZero) {}
4074};
4075
4076struct DISPFlagField : public MDFieldImpl<DISubprogram::DISPFlags> {
4077 DISPFlagField() : MDFieldImpl(DISubprogram::SPFlagZero) {}
4078};
4079
4080struct MDAPSIntField : public MDFieldImpl<APSInt> {
4081 MDAPSIntField() : ImplTy(APSInt()) {}
4082};
4083
4084struct MDSignedField : public MDFieldImpl<int64_t> {
4085 int64_t Min;
4086 int64_t Max;
4087
4088 MDSignedField(int64_t Default = 0)
4089 : ImplTy(Default), Min(INT64_MIN), Max(INT64_MAX) {}
4090 MDSignedField(int64_t Default, int64_t Min, int64_t Max)
4091 : ImplTy(Default), Min(Min), Max(Max) {}
4092};
4093
4094struct MDBoolField : public MDFieldImpl<bool> {
4095 MDBoolField(bool Default = false) : ImplTy(Default) {}
4096};
4097
4098struct MDField : public MDFieldImpl<Metadata *> {
4099 bool AllowNull;
4100
4101 MDField(bool AllowNull = true) : ImplTy(nullptr), AllowNull(AllowNull) {}
4102};
4103
4104struct MDConstant : public MDFieldImpl<ConstantAsMetadata *> {
4105 MDConstant() : ImplTy(nullptr) {}
4106};
4107
4108struct MDStringField : public MDFieldImpl<MDString *> {
4109 bool AllowEmpty;
4110 MDStringField(bool AllowEmpty = true)
4111 : ImplTy(nullptr), AllowEmpty(AllowEmpty) {}
4112};
4113
4114struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
4115 MDFieldList() : ImplTy(SmallVector<Metadata *, 4>()) {}
4116};
4117
4118struct ChecksumKindField : public MDFieldImpl<DIFile::ChecksumKind> {
4119 ChecksumKindField(DIFile::ChecksumKind CSKind) : ImplTy(CSKind) {}
4120};
4121
4122struct MDSignedOrMDField : MDEitherFieldImpl<MDSignedField, MDField> {
4123 MDSignedOrMDField(int64_t Default = 0, bool AllowNull = true)
4124 : ImplTy(MDSignedField(Default), MDField(AllowNull)) {}
4125
4126 MDSignedOrMDField(int64_t Default, int64_t Min, int64_t Max,
4127 bool AllowNull = true)
4128 : ImplTy(MDSignedField(Default, Min, Max), MDField(AllowNull)) {}
4129
4130 bool isMDSignedField() const { return WhatIs == IsTypeA; }
4131 bool isMDField() const { return WhatIs == IsTypeB; }
4132 int64_t getMDSignedValue() const {
4133 assert(isMDSignedField() && "Wrong field type");
4134 return A.Val;
4135 }
4136 Metadata *getMDFieldValue() const {
4137 assert(isMDField() && "Wrong field type");
4138 return B.Val;
4139 }
4140};
4141
4142struct MDSignedOrUnsignedField
4143 : MDEitherFieldImpl<MDSignedField, MDUnsignedField> {
4144 MDSignedOrUnsignedField() : ImplTy(MDSignedField(0), MDUnsignedField(0)) {}
4145
4146 bool isMDSignedField() const { return WhatIs == IsTypeA; }
4147 bool isMDUnsignedField() const { return WhatIs == IsTypeB; }
4148 int64_t getMDSignedValue() const {
4149 assert(isMDSignedField() && "Wrong field type");
4150 return A.Val;
4151 }
4152 uint64_t getMDUnsignedValue() const {
4153 assert(isMDUnsignedField() && "Wrong field type");
4154 return B.Val;
4155 }
4156};
4157
4158} // end anonymous namespace
4159
4160namespace llvm {
4161
4162template <>
4163bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDAPSIntField &Result) {
4164 if (Lex.getKind() != lltok::APSInt)
4165 return tokError("expected integer");
4166
4167 Result.assign(Lex.getAPSIntVal());
4168 Lex.Lex();
4169 return false;
4170}
4171
4172template <>
4173bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4174 MDUnsignedField &Result) {
4175 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
4176 return tokError("expected unsigned integer");
4177
4178 auto &U = Lex.getAPSIntVal();
4179 if (U.ugt(Result.Max))
4180 return tokError("value for '" + Name + "' too large, limit is " +
4181 Twine(Result.Max));
4182 Result.assign(U.getZExtValue());
4183 assert(Result.Val <= Result.Max && "Expected value in range");
4184 Lex.Lex();
4185 return false;
4186}
4187
4188template <>
4189bool LLParser::parseMDField(LocTy Loc, StringRef Name, LineField &Result) {
4190 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4191}
4192template <>
4193bool LLParser::parseMDField(LocTy Loc, StringRef Name, ColumnField &Result) {
4194 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4195}
4196
4197template <>
4198bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfTagField &Result) {
4199 if (Lex.getKind() == lltok::APSInt)
4200 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4201
4202 if (Lex.getKind() != lltok::DwarfTag)
4203 return tokError("expected DWARF tag");
4204
4205 unsigned Tag = dwarf::getTag(Lex.getStrVal());
4206 if (Tag == dwarf::DW_TAG_invalid)
4207 return tokError("invalid DWARF tag" + Twine(" '") + Lex.getStrVal() + "'");
4208 assert(Tag <= Result.Max && "Expected valid DWARF tag");
4209
4210 Result.assign(Tag);
4211 Lex.Lex();
4212 return false;
4213}
4214
4215template <>
4216bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4217 DwarfMacinfoTypeField &Result) {
4218 if (Lex.getKind() == lltok::APSInt)
4219 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4220
4221 if (Lex.getKind() != lltok::DwarfMacinfo)
4222 return tokError("expected DWARF macinfo type");
4223
4224 unsigned Macinfo = dwarf::getMacinfo(Lex.getStrVal());
4225 if (Macinfo == dwarf::DW_MACINFO_invalid)
4226 return tokError("invalid DWARF macinfo type" + Twine(" '") +
4227 Lex.getStrVal() + "'");
4228 assert(Macinfo <= Result.Max && "Expected valid DWARF macinfo type");
4229
4230 Result.assign(Macinfo);
4231 Lex.Lex();
4232 return false;
4233}
4234
4235template <>
4236bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4237 DwarfVirtualityField &Result) {
4238 if (Lex.getKind() == lltok::APSInt)
4239 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4240
4241 if (Lex.getKind() != lltok::DwarfVirtuality)
4242 return tokError("expected DWARF virtuality code");
4243
4244 unsigned Virtuality = dwarf::getVirtuality(Lex.getStrVal());
4245 if (Virtuality == dwarf::DW_VIRTUALITY_invalid)
4246 return tokError("invalid DWARF virtuality code" + Twine(" '") +
4247 Lex.getStrVal() + "'");
4248 assert(Virtuality <= Result.Max && "Expected valid DWARF virtuality code");
4249 Result.assign(Virtuality);
4250 Lex.Lex();
4251 return false;
4252}
4253
4254template <>
4255bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfLangField &Result) {
4256 if (Lex.getKind() == lltok::APSInt)
4257 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4258
4259 if (Lex.getKind() != lltok::DwarfLang)
4260 return tokError("expected DWARF language");
4261
4262 unsigned Lang = dwarf::getLanguage(Lex.getStrVal());
4263 if (!Lang)
4264 return tokError("invalid DWARF language" + Twine(" '") + Lex.getStrVal() +
4265 "'");
4266 assert(Lang <= Result.Max && "Expected valid DWARF language");
4267 Result.assign(Lang);
4268 Lex.Lex();
4269 return false;
4270}
4271
4272template <>
4273bool LLParser::parseMDField(LocTy Loc, StringRef Name, DwarfCCField &Result) {
4274 if (Lex.getKind() == lltok::APSInt)
4275 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4276
4277 if (Lex.getKind() != lltok::DwarfCC)
4278 return tokError("expected DWARF calling convention");
4279
4280 unsigned CC = dwarf::getCallingConvention(Lex.getStrVal());
4281 if (!CC)
4282 return tokError("invalid DWARF calling convention" + Twine(" '") +
4283 Lex.getStrVal() + "'");
4284 assert(CC <= Result.Max && "Expected valid DWARF calling convention");
4285 Result.assign(CC);
4286 Lex.Lex();
4287 return false;
4288}
4289
4290template <>
4291bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4292 EmissionKindField &Result) {
4293 if (Lex.getKind() == lltok::APSInt)
4294 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4295
4296 if (Lex.getKind() != lltok::EmissionKind)
4297 return tokError("expected emission kind");
4298
4299 auto Kind = DICompileUnit::getEmissionKind(Lex.getStrVal());
4300 if (!Kind)
4301 return tokError("invalid emission kind" + Twine(" '") + Lex.getStrVal() +
4302 "'");
4303 assert(*Kind <= Result.Max && "Expected valid emission kind");
4304 Result.assign(*Kind);
4305 Lex.Lex();
4306 return false;
4307}
4308
4309template <>
4310bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4311 NameTableKindField &Result) {
4312 if (Lex.getKind() == lltok::APSInt)
4313 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4314
4315 if (Lex.getKind() != lltok::NameTableKind)
4316 return tokError("expected nameTable kind");
4317
4318 auto Kind = DICompileUnit::getNameTableKind(Lex.getStrVal());
4319 if (!Kind)
4320 return tokError("invalid nameTable kind" + Twine(" '") + Lex.getStrVal() +
4321 "'");
4322 assert(((unsigned)*Kind) <= Result.Max && "Expected valid nameTable kind");
4323 Result.assign((unsigned)*Kind);
4324 Lex.Lex();
4325 return false;
4326}
4327
4328template <>
4329bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4330 DwarfAttEncodingField &Result) {
4331 if (Lex.getKind() == lltok::APSInt)
4332 return parseMDField(Loc, Name, static_cast<MDUnsignedField &>(Result));
4333
4334 if (Lex.getKind() != lltok::DwarfAttEncoding)
4335 return tokError("expected DWARF type attribute encoding");
4336
4337 unsigned Encoding = dwarf::getAttributeEncoding(Lex.getStrVal());
4338 if (!Encoding)
4339 return tokError("invalid DWARF type attribute encoding" + Twine(" '") +
4340 Lex.getStrVal() + "'");
4341 assert(Encoding <= Result.Max && "Expected valid DWARF language");
4342 Result.assign(Encoding);
4343 Lex.Lex();
4344 return false;
4345}
4346
4347/// DIFlagField
4348/// ::= uint32
4349/// ::= DIFlagVector
4350/// ::= DIFlagVector '|' DIFlagFwdDecl '|' uint32 '|' DIFlagPublic
4351template <>
4352bool LLParser::parseMDField(LocTy Loc, StringRef Name, DIFlagField &Result) {
4353
4354 // parser for a single flag.
4355 auto parseFlag = [&](DINode::DIFlags &Val) {
4356 if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
4357 uint32_t TempVal = static_cast<uint32_t>(Val);
4358 bool Res = parseUInt32(TempVal);
4359 Val = static_cast<DINode::DIFlags>(TempVal);
4360 return Res;
4361 }
4362
4363 if (Lex.getKind() != lltok::DIFlag)
4364 return tokError("expected debug info flag");
4365
4366 Val = DINode::getFlag(Lex.getStrVal());
4367 if (!Val)
4368 return tokError(Twine("invalid debug info flag flag '") +
4369 Lex.getStrVal() + "'");
4370 Lex.Lex();
4371 return false;
4372 };
4373
4374 // parse the flags and combine them together.
4375 DINode::DIFlags Combined = DINode::FlagZero;
4376 do {
4377 DINode::DIFlags Val;
4378 if (parseFlag(Val))
4379 return true;
4380 Combined |= Val;
4381 } while (EatIfPresent(lltok::bar));
4382
4383 Result.assign(Combined);
4384 return false;
4385}
4386
4387/// DISPFlagField
4388/// ::= uint32
4389/// ::= DISPFlagVector
4390/// ::= DISPFlagVector '|' DISPFlag* '|' uint32
4391template <>
4392bool LLParser::parseMDField(LocTy Loc, StringRef Name, DISPFlagField &Result) {
4393
4394 // parser for a single flag.
4395 auto parseFlag = [&](DISubprogram::DISPFlags &Val) {
4396 if (Lex.getKind() == lltok::APSInt && !Lex.getAPSIntVal().isSigned()) {
4397 uint32_t TempVal = static_cast<uint32_t>(Val);
4398 bool Res = parseUInt32(TempVal);
4399 Val = static_cast<DISubprogram::DISPFlags>(TempVal);
4400 return Res;
4401 }
4402
4403 if (Lex.getKind() != lltok::DISPFlag)
4404 return tokError("expected debug info flag");
4405
4406 Val = DISubprogram::getFlag(Lex.getStrVal());
4407 if (!Val)
4408 return tokError(Twine("invalid subprogram debug info flag '") +
4409 Lex.getStrVal() + "'");
4410 Lex.Lex();
4411 return false;
4412 };
4413
4414 // parse the flags and combine them together.
4415 DISubprogram::DISPFlags Combined = DISubprogram::SPFlagZero;
4416 do {
4417 DISubprogram::DISPFlags Val;
4418 if (parseFlag(Val))
4419 return true;
4420 Combined |= Val;
4421 } while (EatIfPresent(lltok::bar));
4422
4423 Result.assign(Combined);
4424 return false;
4425}
4426
4427template <>
4428bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDSignedField &Result) {
4429 if (Lex.getKind() != lltok::APSInt)
4430 return tokError("expected signed integer");
4431
4432 auto &S = Lex.getAPSIntVal();
4433 if (S < Result.Min)
4434 return tokError("value for '" + Name + "' too small, limit is " +
4435 Twine(Result.Min));
4436 if (S > Result.Max)
4437 return tokError("value for '" + Name + "' too large, limit is " +
4438 Twine(Result.Max));
4439 Result.assign(S.getExtValue());
4440 assert(Result.Val >= Result.Min && "Expected value in range");
4441 assert(Result.Val <= Result.Max && "Expected value in range");
4442 Lex.Lex();
4443 return false;
4444}
4445
4446template <>
4447bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDBoolField &Result) {
4448 switch (Lex.getKind()) {
4449 default:
4450 return tokError("expected 'true' or 'false'");
4451 case lltok::kw_true:
4452 Result.assign(true);
4453 break;
4454 case lltok::kw_false:
4455 Result.assign(false);
4456 break;
4457 }
4458 Lex.Lex();
4459 return false;
4460}
4461
4462template <>
4463bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDField &Result) {
4464 if (Lex.getKind() == lltok::kw_null) {
4465 if (!Result.AllowNull)
4466 return tokError("'" + Name + "' cannot be null");
4467 Lex.Lex();
4468 Result.assign(nullptr);
4469 return false;
4470 }
4471
4472 Metadata *MD;
4473 if (parseMetadata(MD, nullptr))
4474 return true;
4475
4476 Result.assign(MD);
4477 return false;
4478}
4479
4480template <>
4481bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4482 MDSignedOrMDField &Result) {
4483 // Try to parse a signed int.
4484 if (Lex.getKind() == lltok::APSInt) {
4485 MDSignedField Res = Result.A;
4486 if (!parseMDField(Loc, Name, Res)) {
4487 Result.assign(Res);
4488 return false;
4489 }
4490 return true;
4491 }
4492
4493 // Otherwise, try to parse as an MDField.
4494 MDField Res = Result.B;
4495 if (!parseMDField(Loc, Name, Res)) {
4496 Result.assign(Res);
4497 return false;
4498 }
4499
4500 return true;
4501}
4502
4503template <>
4504bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDStringField &Result) {
4505 LocTy ValueLoc = Lex.getLoc();
4506 std::string S;
4507 if (parseStringConstant(S))
4508 return true;
4509
4510 if (!Result.AllowEmpty && S.empty())
4511 return error(ValueLoc, "'" + Name + "' cannot be empty");
4512
4513 Result.assign(S.empty() ? nullptr : MDString::get(Context, S));
4514 return false;
4515}
4516
4517template <>
4518bool LLParser::parseMDField(LocTy Loc, StringRef Name, MDFieldList &Result) {
4519 SmallVector<Metadata *, 4> MDs;
4520 if (parseMDNodeVector(MDs))
4521 return true;
4522
4523 Result.assign(std::move(MDs));
4524 return false;
4525}
4526
4527template <>
4528bool LLParser::parseMDField(LocTy Loc, StringRef Name,
4529 ChecksumKindField &Result) {
4530 Optional<DIFile::ChecksumKind> CSKind =
4531 DIFile::getChecksumKind(Lex.getStrVal());
4532
4533 if (Lex.getKind() != lltok::ChecksumKind || !CSKind)
4534 return tokError("invalid checksum kind" + Twine(" '") + Lex.getStrVal() +
4535 "'");
4536
4537 Result.assign(*CSKind);
4538 Lex.Lex();
4539 return false;
4540}
4541
4542} // end namespace llvm
4543
4544template <class ParserTy>
4545bool LLParser::parseMDFieldsImplBody(ParserTy ParseField) {
4546 do {
4547 if (Lex.getKind() != lltok::LabelStr)
4548 return tokError("expected field label here");
4549
4550 if (ParseField())
4551 return true;
4552 } while (EatIfPresent(lltok::comma));
4553
4554 return false;
4555}
4556
4557template <class ParserTy>
4558bool LLParser::parseMDFieldsImpl(ParserTy ParseField, LocTy &ClosingLoc) {
4559 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
4560 Lex.Lex();
4561
4562 if (parseToken(lltok::lparen, "expected '(' here"))
4563 return true;
4564 if (Lex.getKind() != lltok::rparen)
4565 if (parseMDFieldsImplBody(ParseField))
4566 return true;
4567
4568 ClosingLoc = Lex.getLoc();
4569 return parseToken(lltok::rparen, "expected ')' here");
4570}
4571
4572template <class FieldTy>
4573bool LLParser::parseMDField(StringRef Name, FieldTy &Result) {
4574 if (Result.Seen)
4575 return tokError("field '" + Name + "' cannot be specified more than once");
4576
4577 LocTy Loc = Lex.getLoc();
4578 Lex.Lex();
4579 return parseMDField(Loc, Name, Result);
4580}
4581
4582bool LLParser::parseSpecializedMDNode(MDNode *&N, bool IsDistinct) {
4583 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
4584
4585#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
4586 if (Lex.getStrVal() == #CLASS) \
4587 return parse##CLASS(N, IsDistinct);
4588#include "llvm/IR/Metadata.def"
4589
4590 return tokError("expected metadata type");
4591}
4592
4593#define DECLARE_FIELD(NAME, TYPE, INIT) TYPE NAME INIT
4594#define NOP_FIELD(NAME, TYPE, INIT)
4595#define REQUIRE_FIELD(NAME, TYPE, INIT) \
4596 if (!NAME.Seen) \
4597 return error(ClosingLoc, "missing required field '" #NAME "'");
4598#define PARSE_MD_FIELD(NAME, TYPE, DEFAULT) \
4599 if (Lex.getStrVal() == #NAME) \
4600 return parseMDField(#NAME, NAME);
4601#define PARSE_MD_FIELDS() \
4602 VISIT_MD_FIELDS(DECLARE_FIELD, DECLARE_FIELD) \
4603 do { \
4604 LocTy ClosingLoc; \
4605 if (parseMDFieldsImpl( \
4606 [&]() -> bool { \
4607 VISIT_MD_FIELDS(PARSE_MD_FIELD, PARSE_MD_FIELD) \
4608 return tokError(Twine("invalid field '") + Lex.getStrVal() + \
4609 "'"); \
4610 }, \
4611 ClosingLoc)) \
4612 return true; \
4613 VISIT_MD_FIELDS(NOP_FIELD, REQUIRE_FIELD) \
4614 } while (false)
4615#define GET_OR_DISTINCT(CLASS, ARGS) \
4616 (IsDistinct ? CLASS::getDistinct ARGS : CLASS::get ARGS)
4617
4618/// parseDILocationFields:
4619/// ::= !DILocation(line: 43, column: 8, scope: !5, inlinedAt: !6,
4620/// isImplicitCode: true)
4621bool LLParser::parseDILocation(MDNode *&Result, bool IsDistinct) {
4622#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4623 OPTIONAL(line, LineField, ); \
4624 OPTIONAL(column, ColumnField, ); \
4625 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
4626 OPTIONAL(inlinedAt, MDField, ); \
4627 OPTIONAL(isImplicitCode, MDBoolField, (false));
4628 PARSE_MD_FIELDS();
4629#undef VISIT_MD_FIELDS
4630
4631 Result =
4632 GET_OR_DISTINCT(DILocation, (Context, line.Val, column.Val, scope.Val,
4633 inlinedAt.Val, isImplicitCode.Val));
4634 return false;
4635}
4636
4637/// parseGenericDINode:
4638/// ::= !GenericDINode(tag: 15, header: "...", operands: {...})
4639bool LLParser::parseGenericDINode(MDNode *&Result, bool IsDistinct) {
4640#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4641 REQUIRED(tag, DwarfTagField, ); \
4642 OPTIONAL(header, MDStringField, ); \
4643 OPTIONAL(operands, MDFieldList, );
4644 PARSE_MD_FIELDS();
4645#undef VISIT_MD_FIELDS
4646
4647 Result = GET_OR_DISTINCT(GenericDINode,
4648 (Context, tag.Val, header.Val, operands.Val));
4649 return false;
4650}
4651
4652/// parseDISubrange:
4653/// ::= !DISubrange(count: 30, lowerBound: 2)
4654/// ::= !DISubrange(count: !node, lowerBound: 2)
4655/// ::= !DISubrange(lowerBound: !node1, upperBound: !node2, stride: !node3)
4656bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) {
4657#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4658 OPTIONAL(count, MDSignedOrMDField, (-1, -1, INT64_MAX, false)); \
4659 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4660 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4661 OPTIONAL(stride, MDSignedOrMDField, );
4662 PARSE_MD_FIELDS();
4663#undef VISIT_MD_FIELDS
4664
4665 Metadata *Count = nullptr;
4666 Metadata *LowerBound = nullptr;
4667 Metadata *UpperBound = nullptr;
4668 Metadata *Stride = nullptr;
4669 if (count.isMDSignedField())
4670 Count = ConstantAsMetadata::get(ConstantInt::getSigned(
4671 Type::getInt64Ty(Context), count.getMDSignedValue()));
4672 else if (count.isMDField())
4673 Count = count.getMDFieldValue();
4674
4675 auto convToMetadata = [&](MDSignedOrMDField Bound) -> Metadata * {
4676 if (Bound.isMDSignedField())
4677 return ConstantAsMetadata::get(ConstantInt::getSigned(
4678 Type::getInt64Ty(Context), Bound.getMDSignedValue()));
4679 if (Bound.isMDField())
4680 return Bound.getMDFieldValue();
4681 return nullptr;
4682 };
4683
4684 LowerBound = convToMetadata(lowerBound);
4685 UpperBound = convToMetadata(upperBound);
4686 Stride = convToMetadata(stride);
4687
4688 Result = GET_OR_DISTINCT(DISubrange,
4689 (Context, Count, LowerBound, UpperBound, Stride));
4690
4691 return false;
4692}
4693
4694/// parseDIGenericSubrange:
4695/// ::= !DIGenericSubrange(lowerBound: !node1, upperBound: !node2, stride:
4696/// !node3)
4697bool LLParser::parseDIGenericSubrange(MDNode *&Result, bool IsDistinct) {
4698#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4699 OPTIONAL(count, MDSignedOrMDField, ); \
4700 OPTIONAL(lowerBound, MDSignedOrMDField, ); \
4701 OPTIONAL(upperBound, MDSignedOrMDField, ); \
4702 OPTIONAL(stride, MDSignedOrMDField, );
4703 PARSE_MD_FIELDS();
4704#undef VISIT_MD_FIELDS
4705
4706 auto ConvToMetadata = [&](MDSignedOrMDField Bound) -> Metadata * {
4707 if (Bound.isMDSignedField())
4708 return DIExpression::get(
4709 Context, {dwarf::DW_OP_consts,
4710 static_cast<uint64_t>(Bound.getMDSignedValue())});
4711 if (Bound.isMDField())
4712 return Bound.getMDFieldValue();
4713 return nullptr;
4714 };
4715
4716 Metadata *Count = ConvToMetadata(count);
4717 Metadata *LowerBound = ConvToMetadata(lowerBound);
4718 Metadata *UpperBound = ConvToMetadata(upperBound);
4719 Metadata *Stride = ConvToMetadata(stride);
4720
4721 Result = GET_OR_DISTINCT(DIGenericSubrange,
4722 (Context, Count, LowerBound, UpperBound, Stride));
4723
4724 return false;
4725}
4726
4727/// parseDIEnumerator:
4728/// ::= !DIEnumerator(value: 30, isUnsigned: true, name: "SomeKind")
4729bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) {
4730#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4731 REQUIRED(name, MDStringField, ); \
4732 REQUIRED(value, MDAPSIntField, ); \
4733 OPTIONAL(isUnsigned, MDBoolField, (false));
4734 PARSE_MD_FIELDS();
4735#undef VISIT_MD_FIELDS
4736
4737 if (isUnsigned.Val && value.Val.isNegative())
4738 return tokError("unsigned enumerator with negative value");
4739
4740 APSInt Value(value.Val);
4741 // Add a leading zero so that unsigned values with the msb set are not
4742 // mistaken for negative values when used for signed enumerators.
4743 if (!isUnsigned.Val && value.Val.isUnsigned() && value.Val.isSignBitSet())
4744 Value = Value.zext(Value.getBitWidth() + 1);
4745
4746 Result =
4747 GET_OR_DISTINCT(DIEnumerator, (Context, Value, isUnsigned.Val, name.Val));
4748
4749 return false;
4750}
4751
4752/// parseDIBasicType:
4753/// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32,
4754/// encoding: DW_ATE_encoding, flags: 0)
4755bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
4756#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4757 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
4758 OPTIONAL(name, MDStringField, ); \
4759 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4760 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4761 OPTIONAL(encoding, DwarfAttEncodingField, ); \
4762 OPTIONAL(flags, DIFlagField, );
4763 PARSE_MD_FIELDS();
4764#undef VISIT_MD_FIELDS
4765
4766 Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
4767 align.Val, encoding.Val, flags.Val));
4768 return false;
4769}
4770
4771/// parseDIStringType:
4772/// ::= !DIStringType(name: "character(4)", size: 32, align: 32)
4773bool LLParser::parseDIStringType(MDNode *&Result, bool IsDistinct) {
4774#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4775 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_string_type)); \
4776 OPTIONAL(name, MDStringField, ); \
4777 OPTIONAL(stringLength, MDField, ); \
4778 OPTIONAL(stringLengthExpression, MDField, ); \
4779 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4780 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4781 OPTIONAL(encoding, DwarfAttEncodingField, );
4782 PARSE_MD_FIELDS();
4783#undef VISIT_MD_FIELDS
4784
4785 Result = GET_OR_DISTINCT(DIStringType,
4786 (Context, tag.Val, name.Val, stringLength.Val,
4787 stringLengthExpression.Val, size.Val, align.Val,
4788 encoding.Val));
4789 return false;
4790}
4791
4792/// parseDIDerivedType:
4793/// ::= !DIDerivedType(tag: DW_TAG_pointer_type, name: "int", file: !0,
4794/// line: 7, scope: !1, baseType: !2, size: 32,
4795/// align: 32, offset: 0, flags: 0, extraData: !3,
4796/// dwarfAddressSpace: 3)
4797bool LLParser::parseDIDerivedType(MDNode *&Result, bool IsDistinct) {
4798#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4799 REQUIRED(tag, DwarfTagField, ); \
4800 OPTIONAL(name, MDStringField, ); \
4801 OPTIONAL(file, MDField, ); \
4802 OPTIONAL(line, LineField, ); \
4803 OPTIONAL(scope, MDField, ); \
4804 REQUIRED(baseType, MDField, ); \
4805 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4806 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4807 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
4808 OPTIONAL(flags, DIFlagField, ); \
4809 OPTIONAL(extraData, MDField, ); \
4810 OPTIONAL(dwarfAddressSpace, MDUnsignedField, (UINT32_MAX, UINT32_MAX));
4811 PARSE_MD_FIELDS();
4812#undef VISIT_MD_FIELDS
4813
4814 Optional<unsigned> DWARFAddressSpace;
4815 if (dwarfAddressSpace.Val != UINT32_MAX)
4816 DWARFAddressSpace = dwarfAddressSpace.Val;
4817
4818 Result = GET_OR_DISTINCT(DIDerivedType,
4819 (Context, tag.Val, name.Val, file.Val, line.Val,
4820 scope.Val, baseType.Val, size.Val, align.Val,
4821 offset.Val, DWARFAddressSpace, flags.Val,
4822 extraData.Val));
4823 return false;
4824}
4825
4826bool LLParser::parseDICompositeType(MDNode *&Result, bool IsDistinct) {
4827#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4828 REQUIRED(tag, DwarfTagField, ); \
4829 OPTIONAL(name, MDStringField, ); \
4830 OPTIONAL(file, MDField, ); \
4831 OPTIONAL(line, LineField, ); \
4832 OPTIONAL(scope, MDField, ); \
4833 OPTIONAL(baseType, MDField, ); \
4834 OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
4835 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
4836 OPTIONAL(offset, MDUnsignedField, (0, UINT64_MAX)); \
4837 OPTIONAL(flags, DIFlagField, ); \
4838 OPTIONAL(elements, MDField, ); \
4839 OPTIONAL(runtimeLang, DwarfLangField, ); \
4840 OPTIONAL(vtableHolder, MDField, ); \
4841 OPTIONAL(templateParams, MDField, ); \
4842 OPTIONAL(identifier, MDStringField, ); \
4843 OPTIONAL(discriminator, MDField, ); \
4844 OPTIONAL(dataLocation, MDField, ); \
4845 OPTIONAL(associated, MDField, ); \
4846 OPTIONAL(allocated, MDField, ); \
4847 OPTIONAL(rank, MDSignedOrMDField, );
4848 PARSE_MD_FIELDS();
4849#undef VISIT_MD_FIELDS
4850
4851 Metadata *Rank = nullptr;
4852 if (rank.isMDSignedField())
4853 Rank = ConstantAsMetadata::get(ConstantInt::getSigned(
4854 Type::getInt64Ty(Context), rank.getMDSignedValue()));
4855 else if (rank.isMDField())
4856 Rank = rank.getMDFieldValue();
4857
4858 // If this has an identifier try to build an ODR type.
4859 if (identifier.Val)
4860 if (auto *CT = DICompositeType::buildODRType(
4861 Context, *identifier.Val, tag.Val, name.Val, file.Val, line.Val,
4862 scope.Val, baseType.Val, size.Val, align.Val, offset.Val, flags.Val,
4863 elements.Val, runtimeLang.Val, vtableHolder.Val, templateParams.Val,
4864 discriminator.Val, dataLocation.Val, associated.Val, allocated.Val,
4865 Rank)) {
4866 Result = CT;
4867 return false;
4868 }
4869
4870 // Create a new node, and save it in the context if it belongs in the type
4871 // map.
4872 Result = GET_OR_DISTINCT(
4873 DICompositeType,
4874 (Context, tag.Val, name.Val, file.Val, line.Val, scope.Val, baseType.Val,
4875 size.Val, align.Val, offset.Val, flags.Val, elements.Val,
4876 runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val,
4877 discriminator.Val, dataLocation.Val, associated.Val, allocated.Val,
4878 Rank));
4879 return false;
4880}
4881
4882bool LLParser::parseDISubroutineType(MDNode *&Result, bool IsDistinct) {
4883#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4884 OPTIONAL(flags, DIFlagField, ); \
4885 OPTIONAL(cc, DwarfCCField, ); \
4886 REQUIRED(types, MDField, );
4887 PARSE_MD_FIELDS();
4888#undef VISIT_MD_FIELDS
4889
4890 Result = GET_OR_DISTINCT(DISubroutineType,
4891 (Context, flags.Val, cc.Val, types.Val));
4892 return false;
4893}
4894
4895/// parseDIFileType:
4896/// ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir",
4897/// checksumkind: CSK_MD5,
4898/// checksum: "000102030405060708090a0b0c0d0e0f",
4899/// source: "source file contents")
4900bool LLParser::parseDIFile(MDNode *&Result, bool IsDistinct) {
4901 // The default constructed value for checksumkind is required, but will never
4902 // be used, as the parser checks if the field was actually Seen before using
4903 // the Val.
4904#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4905 REQUIRED(filename, MDStringField, ); \
4906 REQUIRED(directory, MDStringField, ); \
4907 OPTIONAL(checksumkind, ChecksumKindField, (DIFile::CSK_MD5)); \
4908 OPTIONAL(checksum, MDStringField, ); \
4909 OPTIONAL(source, MDStringField, );
4910 PARSE_MD_FIELDS();
4911#undef VISIT_MD_FIELDS
4912
4913 Optional<DIFile::ChecksumInfo<MDString *>> OptChecksum;
4914 if (checksumkind.Seen && checksum.Seen)
4915 OptChecksum.emplace(checksumkind.Val, checksum.Val);
4916 else if (checksumkind.Seen || checksum.Seen)
4917 return Lex.Error("'checksumkind' and 'checksum' must be provided together");
4918
4919 Optional<MDString *> OptSource;
4920 if (source.Seen)
4921 OptSource = source.Val;
4922 Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val,
4923 OptChecksum, OptSource));
4924 return false;
4925}
4926
4927/// parseDICompileUnit:
4928/// ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
4929/// isOptimized: true, flags: "-O2", runtimeVersion: 1,
4930/// splitDebugFilename: "abc.debug",
4931/// emissionKind: FullDebug, enums: !1, retainedTypes: !2,
4932/// globals: !4, imports: !5, macros: !6, dwoId: 0x0abcd,
4933/// sysroot: "/", sdk: "MacOSX.sdk")
4934bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
4935 if (!IsDistinct)
4936 return Lex.Error("missing 'distinct', required for !DICompileUnit");
4937
4938#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4939 REQUIRED(language, DwarfLangField, ); \
4940 REQUIRED(file, MDField, (/* AllowNull */ false)); \
4941 OPTIONAL(producer, MDStringField, ); \
4942 OPTIONAL(isOptimized, MDBoolField, ); \
4943 OPTIONAL(flags, MDStringField, ); \
4944 OPTIONAL(runtimeVersion, MDUnsignedField, (0, UINT32_MAX)); \
4945 OPTIONAL(splitDebugFilename, MDStringField, ); \
4946 OPTIONAL(emissionKind, EmissionKindField, ); \
4947 OPTIONAL(enums, MDField, ); \
4948 OPTIONAL(retainedTypes, MDField, ); \
4949 OPTIONAL(globals, MDField, ); \
4950 OPTIONAL(imports, MDField, ); \
4951 OPTIONAL(macros, MDField, ); \
4952 OPTIONAL(dwoId, MDUnsignedField, ); \
4953 OPTIONAL(splitDebugInlining, MDBoolField, = true); \
4954 OPTIONAL(debugInfoForProfiling, MDBoolField, = false); \
4955 OPTIONAL(nameTableKind, NameTableKindField, ); \
4956 OPTIONAL(rangesBaseAddress, MDBoolField, = false); \
4957 OPTIONAL(sysroot, MDStringField, ); \
4958 OPTIONAL(sdk, MDStringField, );
4959 PARSE_MD_FIELDS();
4960#undef VISIT_MD_FIELDS
4961
4962 Result = DICompileUnit::getDistinct(
4963 Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
4964 runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
4965 retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
4966 splitDebugInlining.Val, debugInfoForProfiling.Val, nameTableKind.Val,
4967 rangesBaseAddress.Val, sysroot.Val, sdk.Val);
4968 return false;
4969}
4970
4971/// parseDISubprogram:
4972/// ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
4973/// file: !1, line: 7, type: !2, isLocal: false,
4974/// isDefinition: true, scopeLine: 8, containingType: !3,
4975/// virtuality: DW_VIRTUALTIY_pure_virtual,
4976/// virtualIndex: 10, thisAdjustment: 4, flags: 11,
4977/// spFlags: 10, isOptimized: false, templateParams: !4,
4978/// declaration: !5, retainedNodes: !6, thrownTypes: !7)
4979bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
4980 auto Loc = Lex.getLoc();
4981#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
4982 OPTIONAL(scope, MDField, ); \
4983 OPTIONAL(name, MDStringField, ); \
4984 OPTIONAL(linkageName, MDStringField, ); \
4985 OPTIONAL(file, MDField, ); \
4986 OPTIONAL(line, LineField, ); \
4987 OPTIONAL(type, MDField, ); \
4988 OPTIONAL(isLocal, MDBoolField, ); \
4989 OPTIONAL(isDefinition, MDBoolField, (true)); \
4990 OPTIONAL(scopeLine, LineField, ); \
4991 OPTIONAL(containingType, MDField, ); \
4992 OPTIONAL(virtuality, DwarfVirtualityField, ); \
4993 OPTIONAL(virtualIndex, MDUnsignedField, (0, UINT32_MAX)); \
4994 OPTIONAL(thisAdjustment, MDSignedField, (0, INT32_MIN, INT32_MAX)); \
4995 OPTIONAL(flags, DIFlagField, ); \
4996 OPTIONAL(spFlags, DISPFlagField, ); \
4997 OPTIONAL(isOptimized, MDBoolField, ); \
4998 OPTIONAL(unit, MDField, ); \
4999 OPTIONAL(templateParams, MDField, ); \
5000 OPTIONAL(declaration, MDField, ); \
5001 OPTIONAL(retainedNodes, MDField, ); \
5002 OPTIONAL(thrownTypes, MDField, );
5003 PARSE_MD_FIELDS();
5004#undef VISIT_MD_FIELDS
5005
5006 // An explicit spFlags field takes precedence over individual fields in
5007 // older IR versions.
5008 DISubprogram::DISPFlags SPFlags =
5009 spFlags.Seen ? spFlags.Val
5010 : DISubprogram::toSPFlags(isLocal.Val, isDefinition.Val,
5011 isOptimized.Val, virtuality.Val);
5012 if ((SPFlags & DISubprogram::SPFlagDefinition) && !IsDistinct)
5013 return Lex.Error(
5014 Loc,
5015 "missing 'distinct', required for !DISubprogram that is a Definition");
5016 Result = GET_OR_DISTINCT(
5017 DISubprogram,
5018 (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,
5019 type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
5020 thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
5021 declaration.Val, retainedNodes.Val, thrownTypes.Val));
5022 return false;
5023}
5024
5025/// parseDILexicalBlock:
5026/// ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
5027bool LLParser::parseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
5028#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5029 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
5030 OPTIONAL(file, MDField, ); \
5031 OPTIONAL(line, LineField, ); \
5032 OPTIONAL(column, ColumnField, );
5033 PARSE_MD_FIELDS();
5034#undef VISIT_MD_FIELDS
5035
5036 Result = GET_OR_DISTINCT(
5037 DILexicalBlock, (Context, scope.Val, file.Val, line.Val, column.Val));
5038 return false;
5039}
5040
5041/// parseDILexicalBlockFile:
5042/// ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
5043bool LLParser::parseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
5044#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5045 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
5046 OPTIONAL(file, MDField, ); \
5047 REQUIRED(discriminator, MDUnsignedField, (0, UINT32_MAX));
5048 PARSE_MD_FIELDS();
5049#undef VISIT_MD_FIELDS
5050
5051 Result = GET_OR_DISTINCT(DILexicalBlockFile,
5052 (Context, scope.Val, file.Val, discriminator.Val));
5053 return false;
5054}
5055
5056/// parseDICommonBlock:
5057/// ::= !DICommonBlock(scope: !0, file: !2, name: "COMMON name", line: 9)
5058bool LLParser::parseDICommonBlock(MDNode *&Result, bool IsDistinct) {
5059#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5060 REQUIRED(scope, MDField, ); \
5061 OPTIONAL(declaration, MDField, ); \
5062 OPTIONAL(name, MDStringField, ); \
5063 OPTIONAL(file, MDField, ); \
5064 OPTIONAL(line, LineField, );
5065 PARSE_MD_FIELDS();
5066#undef VISIT_MD_FIELDS
5067
5068 Result = GET_OR_DISTINCT(DICommonBlock,
5069 (Context, scope.Val, declaration.Val, name.Val,
5070 file.Val, line.Val));
5071 return false;
5072}
5073
5074/// parseDINamespace:
5075/// ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
5076bool LLParser::parseDINamespace(MDNode *&Result, bool IsDistinct) {
5077#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5078 REQUIRED(scope, MDField, ); \
5079 OPTIONAL(name, MDStringField, ); \
5080 OPTIONAL(exportSymbols, MDBoolField, );
5081 PARSE_MD_FIELDS();
5082#undef VISIT_MD_FIELDS
5083
5084 Result = GET_OR_DISTINCT(DINamespace,
5085 (Context, scope.Val, name.Val, exportSymbols.Val));
5086 return false;
5087}
5088
5089/// parseDIMacro:
5090/// ::= !DIMacro(macinfo: type, line: 9, name: "SomeMacro", value:
5091/// "SomeValue")
5092bool LLParser::parseDIMacro(MDNode *&Result, bool IsDistinct) {
5093#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5094 REQUIRED(type, DwarfMacinfoTypeField, ); \
5095 OPTIONAL(line, LineField, ); \
5096 REQUIRED(name, MDStringField, ); \
5097 OPTIONAL(value, MDStringField, );
5098 PARSE_MD_FIELDS();
5099#undef VISIT_MD_FIELDS
5100
5101 Result = GET_OR_DISTINCT(DIMacro,
5102 (Context, type.Val, line.Val, name.Val, value.Val));
5103 return false;
5104}
5105
5106/// parseDIMacroFile:
5107/// ::= !DIMacroFile(line: 9, file: !2, nodes: !3)
5108bool LLParser::parseDIMacroFile(MDNode *&Result, bool IsDistinct) {
5109#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5110 OPTIONAL(type, DwarfMacinfoTypeField, (dwarf::DW_MACINFO_start_file)); \
5111 OPTIONAL(line, LineField, ); \
5112 REQUIRED(file, MDField, ); \
5113 OPTIONAL(nodes, MDField, );
5114 PARSE_MD_FIELDS();
5115#undef VISIT_MD_FIELDS
5116
5117 Result = GET_OR_DISTINCT(DIMacroFile,
5118 (Context, type.Val, line.Val, file.Val, nodes.Val));
5119 return false;
5120}
5121
5122/// parseDIModule:
5123/// ::= !DIModule(scope: !0, name: "SomeModule", configMacros:
5124/// "-DNDEBUG", includePath: "/usr/include", apinotes: "module.apinotes",
5125/// file: !1, line: 4, isDecl: false)
5126bool LLParser::parseDIModule(MDNode *&Result, bool IsDistinct) {
5127#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5128 REQUIRED(scope, MDField, ); \
5129 REQUIRED(name, MDStringField, ); \
5130 OPTIONAL(configMacros, MDStringField, ); \
5131 OPTIONAL(includePath, MDStringField, ); \
5132 OPTIONAL(apinotes, MDStringField, ); \
5133 OPTIONAL(file, MDField, ); \
5134 OPTIONAL(line, LineField, ); \
5135 OPTIONAL(isDecl, MDBoolField, );
5136 PARSE_MD_FIELDS();
5137#undef VISIT_MD_FIELDS
5138
5139 Result = GET_OR_DISTINCT(DIModule, (Context, file.Val, scope.Val, name.Val,
5140 configMacros.Val, includePath.Val,
5141 apinotes.Val, line.Val, isDecl.Val));
5142 return false;
5143}
5144
5145/// parseDITemplateTypeParameter:
5146/// ::= !DITemplateTypeParameter(name: "Ty", type: !1, defaulted: false)
5147bool LLParser::parseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
5148#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5149 OPTIONAL(name, MDStringField, ); \
5150 REQUIRED(type, MDField, ); \
5151 OPTIONAL(defaulted, MDBoolField, );
5152 PARSE_MD_FIELDS();
5153#undef VISIT_MD_FIELDS
5154
5155 Result = GET_OR_DISTINCT(DITemplateTypeParameter,
5156 (Context, name.Val, type.Val, defaulted.Val));
5157 return false;
5158}
5159
5160/// parseDITemplateValueParameter:
5161/// ::= !DITemplateValueParameter(tag: DW_TAG_template_value_parameter,
5162/// name: "V", type: !1, defaulted: false,
5163/// value: i32 7)
5164bool LLParser::parseDITemplateValueParameter(MDNode *&Result, bool IsDistinct) {
5165#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5166 OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_template_value_parameter)); \
5167 OPTIONAL(name, MDStringField, ); \
5168 OPTIONAL(type, MDField, ); \
5169 OPTIONAL(defaulted, MDBoolField, ); \
5170 REQUIRED(value, MDField, );
5171
5172 PARSE_MD_FIELDS();
5173#undef VISIT_MD_FIELDS
5174
5175 Result = GET_OR_DISTINCT(
5176 DITemplateValueParameter,
5177 (Context, tag.Val, name.Val, type.Val, defaulted.Val, value.Val));
5178 return false;
5179}
5180
5181/// parseDIGlobalVariable:
5182/// ::= !DIGlobalVariable(scope: !0, name: "foo", linkageName: "foo",
5183/// file: !1, line: 7, type: !2, isLocal: false,
5184/// isDefinition: true, templateParams: !3,
5185/// declaration: !4, align: 8)
5186bool LLParser::parseDIGlobalVariable(MDNode *&Result, bool IsDistinct) {
5187#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5188 REQUIRED(name, MDStringField, (/* AllowEmpty */ false)); \
5189 OPTIONAL(scope, MDField, ); \
5190 OPTIONAL(linkageName, MDStringField, ); \
5191 OPTIONAL(file, MDField, ); \
5192 OPTIONAL(line, LineField, ); \
5193 OPTIONAL(type, MDField, ); \
5194 OPTIONAL(isLocal, MDBoolField, ); \
5195 OPTIONAL(isDefinition, MDBoolField, (true)); \
5196 OPTIONAL(templateParams, MDField, ); \
5197 OPTIONAL(declaration, MDField, ); \
5198 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));
5199 PARSE_MD_FIELDS();
5200#undef VISIT_MD_FIELDS
5201
5202 Result =
5203 GET_OR_DISTINCT(DIGlobalVariable,
5204 (Context, scope.Val, name.Val, linkageName.Val, file.Val,
5205 line.Val, type.Val, isLocal.Val, isDefinition.Val,
5206 declaration.Val, templateParams.Val, align.Val));
5207 return false;
5208}
5209
5210/// parseDILocalVariable:
5211/// ::= !DILocalVariable(arg: 7, scope: !0, name: "foo",
5212/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
5213/// align: 8)
5214/// ::= !DILocalVariable(scope: !0, name: "foo",
5215/// file: !1, line: 7, type: !2, arg: 2, flags: 7,
5216/// align: 8)
5217bool LLParser::parseDILocalVariable(MDNode *&Result, bool IsDistinct) {
5218#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5219 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
5220 OPTIONAL(name, MDStringField, ); \
5221 OPTIONAL(arg, MDUnsignedField, (0, UINT16_MAX)); \
5222 OPTIONAL(file, MDField, ); \
5223 OPTIONAL(line, LineField, ); \
5224 OPTIONAL(type, MDField, ); \
5225 OPTIONAL(flags, DIFlagField, ); \
5226 OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));
5227 PARSE_MD_FIELDS();
5228#undef VISIT_MD_FIELDS
5229
5230 Result = GET_OR_DISTINCT(DILocalVariable,
5231 (Context, scope.Val, name.Val, file.Val, line.Val,
5232 type.Val, arg.Val, flags.Val, align.Val));
5233 return false;
5234}
5235
5236/// parseDILabel:
5237/// ::= !DILabel(scope: !0, name: "foo", file: !1, line: 7)
5238bool LLParser::parseDILabel(MDNode *&Result, bool IsDistinct) {
5239#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5240 REQUIRED(scope, MDField, (/* AllowNull */ false)); \
5241 REQUIRED(name, MDStringField, ); \
5242 REQUIRED(file, MDField, ); \
5243 REQUIRED(line, LineField, );
5244 PARSE_MD_FIELDS();
5245#undef VISIT_MD_FIELDS
5246
5247 Result = GET_OR_DISTINCT(DILabel,
5248 (Context, scope.Val, name.Val, file.Val, line.Val));
5249 return false;
5250}
5251
5252/// parseDIExpression:
5253/// ::= !DIExpression(0, 7, -1)
5254bool LLParser::parseDIExpression(MDNode *&Result, bool IsDistinct) {
5255 assert(Lex.getKind() == lltok::MetadataVar && "Expected metadata type name");
5256 Lex.Lex();
5257
5258 if (parseToken(lltok::lparen, "expected '(' here"))
5259 return true;
5260
5261 SmallVector<uint64_t, 8> Elements;
5262 if (Lex.getKind() != lltok::rparen)
5263 do {
5264 if (Lex.getKind() == lltok::DwarfOp) {
5265 if (unsigned Op = dwarf::getOperationEncoding(Lex.getStrVal())) {
5266 Lex.Lex();
5267 Elements.push_back(Op);
5268 continue;
5269 }
5270 return tokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
5271 }
5272
5273 if (Lex.getKind() == lltok::DwarfAttEncoding) {
5274 if (unsigned Op = dwarf::getAttributeEncoding(Lex.getStrVal())) {
5275 Lex.Lex();
5276 Elements.push_back(Op);
5277 continue;
5278 }
5279 return tokError(Twine("invalid DWARF attribute encoding '") +
5280 Lex.getStrVal() + "'");
5281 }
5282
5283 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
5284 return tokError("expected unsigned integer");
5285
5286 auto &U = Lex.getAPSIntVal();
5287 if (U.ugt(UINT64_MAX))
5288 return tokError("element too large, limit is " + Twine(UINT64_MAX));
5289 Elements.push_back(U.getZExtValue());
5290 Lex.Lex();
5291 } while (EatIfPresent(lltok::comma));
5292
5293 if (parseToken(lltok::rparen, "expected ')' here"))
5294 return true;
5295
5296 Result = GET_OR_DISTINCT(DIExpression, (Context, Elements));
5297 return false;
5298}
5299
5300/// parseDIGlobalVariableExpression:
5301/// ::= !DIGlobalVariableExpression(var: !0, expr: !1)
5302bool LLParser::parseDIGlobalVariableExpression(MDNode *&Result,
5303 bool IsDistinct) {
5304#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5305 REQUIRED(var, MDField, ); \
5306 REQUIRED(expr, MDField, );
5307 PARSE_MD_FIELDS();
5308#undef VISIT_MD_FIELDS
5309
5310 Result =
5311 GET_OR_DISTINCT(DIGlobalVariableExpression, (Context, var.Val, expr.Val));
5312 return false;
5313}
5314
5315/// parseDIObjCProperty:
5316/// ::= !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
5317/// getter: "getFoo", attributes: 7, type: !2)
5318bool LLParser::parseDIObjCProperty(MDNode *&Result, bool IsDistinct) {
5319#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5320 OPTIONAL(name, MDStringField, ); \
5321 OPTIONAL(file, MDField, ); \
5322 OPTIONAL(line, LineField, ); \
5323 OPTIONAL(setter, MDStringField, ); \
5324 OPTIONAL(getter, MDStringField, ); \
5325 OPTIONAL(attributes, MDUnsignedField, (0, UINT32_MAX)); \
5326 OPTIONAL(type, MDField, );
5327 PARSE_MD_FIELDS();
5328#undef VISIT_MD_FIELDS
5329
5330 Result = GET_OR_DISTINCT(DIObjCProperty,
5331 (Context, name.Val, file.Val, line.Val, setter.Val,
5332 getter.Val, attributes.Val, type.Val));
5333 return false;
5334}
5335
5336/// parseDIImportedEntity:
5337/// ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
5338/// line: 7, name: "foo")
5339bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
5340#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
5341 REQUIRED(tag, DwarfTagField, ); \
5342 REQUIRED(scope, MDField, ); \
5343 OPTIONAL(entity, MDField, ); \
5344 OPTIONAL(file, MDField, ); \
5345 OPTIONAL(line, LineField, ); \
5346 OPTIONAL(name, MDStringField, );
5347 PARSE_MD_FIELDS();
5348#undef VISIT_MD_FIELDS
5349
5350 Result = GET_OR_DISTINCT(
5351 DIImportedEntity,
5352 (Context, tag.Val, scope.Val, entity.Val, file.Val, line.Val, name.Val));
5353 return false;
5354}
5355
5356#undef PARSE_MD_FIELD
5357#undef NOP_FIELD
5358#undef REQUIRE_FIELD
5359#undef DECLARE_FIELD
5360
5361/// parseMetadataAsValue
5362/// ::= metadata i32 %local
5363/// ::= metadata i32 @global
5364/// ::= metadata i32 7
5365/// ::= metadata !0
5366/// ::= metadata !{...}
5367/// ::= metadata !"string"
5368bool LLParser::parseMetadataAsValue(Value *&V, PerFunctionState &PFS) {
5369 // Note: the type 'metadata' has already been parsed.
5370 Metadata *MD;
5371 if (parseMetadata(MD, &PFS))
5372 return true;
5373
5374 V = MetadataAsValue::get(Context, MD);
5375 return false;
5376}
5377
5378/// parseValueAsMetadata
5379/// ::= i32 %local
5380/// ::= i32 @global
5381/// ::= i32 7
5382bool LLParser::parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
5383 PerFunctionState *PFS) {
5384 Type *Ty;
5385 LocTy Loc;
5386 if (parseType(Ty, TypeMsg, Loc))
5387 return true;
5388 if (Ty->isMetadataTy())
5389 return error(Loc, "invalid metadata-value-metadata roundtrip");
5390
5391 Value *V;
5392 if (parseValue(Ty, V, PFS))
5393 return true;
5394
5395 MD = ValueAsMetadata::get(V);
5396 return false;
5397}
5398
5399/// parseMetadata
5400/// ::= i32 %local
5401/// ::= i32 @global
5402/// ::= i32 7
5403/// ::= !42
5404/// ::= !{...}
5405/// ::= !"string"
5406/// ::= !DILocation(...)
5407bool LLParser::parseMetadata(Metadata *&MD, PerFunctionState *PFS) {
5408 if (Lex.getKind() == lltok::MetadataVar) {
5409 MDNode *N;
5410 if (parseSpecializedMDNode(N))
5411 return true;
5412 MD = N;
5413 return false;
5414 }
5415
5416 // ValueAsMetadata:
5417 // <type> <value>
5418 if (Lex.getKind() != lltok::exclaim)
5419 return parseValueAsMetadata(MD, "expected metadata operand", PFS);
5420
5421 // '!'.
5422 assert(Lex.getKind() == lltok::exclaim && "Expected '!' here");
5423 Lex.Lex();
5424
5425 // MDString:
5426 // ::= '!' STRINGCONSTANT
5427 if (Lex.getKind() == lltok::StringConstant) {
5428 MDString *S;
5429 if (parseMDString(S))
5430 return true;
5431 MD = S;
5432 return false;
5433 }
5434
5435 // MDNode:
5436 // !{ ... }
5437 // !7
5438 MDNode *N;
5439 if (parseMDNodeTail(N))
5440 return true;
5441 MD = N;
5442 return false;
5443}
5444
5445//===----------------------------------------------------------------------===//
5446// Function Parsing.
5447//===----------------------------------------------------------------------===//
5448
5449bool LLParser::convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
5450 PerFunctionState *PFS, bool IsCall) {
5451 if (Ty->isFunctionTy())
5452 return error(ID.Loc, "functions are not values, refer to them as pointers");
5453
5454 switch (ID.Kind) {
5455 case ValID::t_LocalID:
5456 if (!PFS)
5457 return error(ID.Loc, "invalid use of function-local name");
5458 V = PFS->getVal(ID.UIntVal, Ty, ID.Loc, IsCall);
5459 return V == nullptr;
5460 case ValID::t_LocalName:
5461 if (!PFS)
5462 return error(ID.Loc, "invalid use of function-local name");
5463 V = PFS->getVal(ID.StrVal, Ty, ID.Loc, IsCall);
5464 return V == nullptr;
5465 case ValID::t_InlineAsm: {
5466 if (!ID.FTy || !InlineAsm::Verify(ID.FTy, ID.StrVal2))
5467 return error(ID.Loc, "invalid type for inline asm constraint string");
5468 V = InlineAsm::get(ID.FTy, ID.StrVal, ID.StrVal2, ID.UIntVal & 1,
5469 (ID.UIntVal >> 1) & 1,
5470 (InlineAsm::AsmDialect(ID.UIntVal >> 2)));
5471 return false;
5472 }
5473 case ValID::t_GlobalName:
5474 V = getGlobalVal(ID.StrVal, Ty, ID.Loc, IsCall);
5475 return V == nullptr;
5476 case ValID::t_GlobalID:
5477 V = getGlobalVal(ID.UIntVal, Ty, ID.Loc, IsCall);
5478 return V == nullptr;
5479 case ValID::t_APSInt:
5480 if (!Ty->isIntegerTy())
5481 return error(ID.Loc, "integer constant must have integer type");
5482 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
5483 V = ConstantInt::get(Context, ID.APSIntVal);
5484 return false;
5485 case ValID::t_APFloat:
5486 if (!Ty->isFloatingPointTy() ||
5487 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
5488 return error(ID.Loc, "floating point constant invalid for type");
5489
5490 // The lexer has no type info, so builds all half, bfloat, float, and double
5491 // FP constants as double. Fix this here. Long double does not need this.
5492 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble()) {
5493 // Check for signaling before potentially converting and losing that info.
5494 bool IsSNAN = ID.APFloatVal.isSignaling();
5495 bool Ignored;
5496 if (Ty->isHalfTy())
5497 ID.APFloatVal.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5498 &Ignored);
5499 else if (Ty->isBFloatTy())
5500 ID.APFloatVal.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven,
5501 &Ignored);
5502 else if (Ty->isFloatTy())
5503 ID.APFloatVal.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
5504 &Ignored);
5505 if (IsSNAN) {
5506 // The convert call above may quiet an SNaN, so manufacture another
5507 // SNaN. The bitcast works because the payload (significand) parameter
5508 // is truncated to fit.
5509 APInt Payload = ID.APFloatVal.bitcastToAPInt();
5510 ID.APFloatVal = APFloat::getSNaN(ID.APFloatVal.getSemantics(),
5511 ID.APFloatVal.isNegative(), &Payload);
5512 }
5513 }
5514 V = ConstantFP::get(Context, ID.APFloatVal);
5515
5516 if (V->getType() != Ty)
5517 return error(ID.Loc, "floating point constant does not have type '" +
5518 getTypeString(Ty) + "'");
5519
5520 return false;
5521 case ValID::t_Null:
5522 if (!Ty->isPointerTy())
5523 return error(ID.Loc, "null must be a pointer type");
5524 V = ConstantPointerNull::get(cast<PointerType>(Ty));
5525 return false;
5526 case ValID::t_Undef:
5527 // FIXME: LabelTy should not be a first-class type.
5528 if (!Ty->isFirstClassType() || Ty->isLabelTy())
5529 return error(ID.Loc, "invalid type for undef constant");
5530 V = UndefValue::get(Ty);
5531 return false;
5532 case ValID::t_EmptyArray:
5533 if (!Ty->isArrayTy() || cast<ArrayType>(Ty)->getNumElements() != 0)
5534 return error(ID.Loc, "invalid empty array initializer");
5535 V = UndefValue::get(Ty);
5536 return false;
5537 case ValID::t_Zero:
5538 // FIXME: LabelTy should not be a first-class type.
5539 if (!Ty->isFirstClassType() || Ty->isLabelTy())
5540 return error(ID.Loc, "invalid type for null constant");
5541 V = Constant::getNullValue(Ty);
5542 return false;
5543 case ValID::t_None:
5544 if (!Ty->isTokenTy())
5545 return error(ID.Loc, "invalid type for none constant");
5546 V = Constant::getNullValue(Ty);
5547 return false;
5548 case ValID::t_Poison:
5549 // FIXME: LabelTy should not be a first-class type.
5550 if (!Ty->isFirstClassType() || Ty->isLabelTy())
5551 return error(ID.Loc, "invalid type for poison constant");
5552 V = PoisonValue::get(Ty);
5553 return false;
5554 case ValID::t_Constant:
5555 if (ID.ConstantVal->getType() != Ty)
5556 return error(ID.Loc, "constant expression type mismatch");
5557 V = ID.ConstantVal;
5558 return false;
5559 case ValID::t_ConstantStruct:
5560 case ValID::t_PackedConstantStruct:
5561 if (StructType *ST = dyn_cast<StructType>(Ty)) {
5562 if (ST->getNumElements() != ID.UIntVal)
5563 return error(ID.Loc,
5564 "initializer with struct type has wrong # elements");
5565 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
5566 return error(ID.Loc, "packed'ness of initializer and type don't match");
5567
5568 // Verify that the elements are compatible with the structtype.
5569 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
5570 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
5571 return error(
5572 ID.Loc,
5573 "element " + Twine(i) +
5574 " of struct initializer doesn't match struct element type");
5575
5576 V = ConstantStruct::get(
5577 ST, makeArrayRef(ID.ConstantStructElts.get(), ID.UIntVal));
5578 } else
5579 return error(ID.Loc, "constant expression type mismatch");
5580 return false;
5581 }
5582 llvm_unreachable("Invalid ValID");
5583}
5584
5585bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
5586 C = nullptr;
5587 ValID ID;
5588 auto Loc = Lex.getLoc();
5589 if (parseValID(ID, /*PFS=*/nullptr))
5590 return true;
5591 switch (ID.Kind) {
5592 case ValID::t_APSInt:
5593 case ValID::t_APFloat:
5594 case ValID::t_Undef:
5595 case ValID::t_Constant:
5596 case ValID::t_ConstantStruct:
5597 case ValID::t_PackedConstantStruct: {
5598 Value *V;
5599 if (convertValIDToValue(Ty, ID, V, /*PFS=*/nullptr, /*IsCall=*/false))
5600 return true;
5601 assert(isa<Constant>(V) && "Expected a constant value");
5602 C = cast<Constant>(V);
5603 return false;
5604 }
5605 case ValID::t_Null:
5606 C = Constant::getNullValue(Ty);
5607 return false;
5608 default:
5609 return error(Loc, "expected a constant value");
5610 }
5611}
5612
5613bool LLParser::parseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
5614 V = nullptr;
5615 ValID ID;
5616 return parseValID(ID, PFS) ||
5617 convertValIDToValue(Ty, ID, V, PFS, /*IsCall=*/false);
5618}
5619
5620bool LLParser::parseTypeAndValue(Value *&V, PerFunctionState *PFS) {
5621 Type *Ty = nullptr;
5622 return parseType(Ty) || parseValue(Ty, V, PFS);
5623}
5624
5625bool LLParser::parseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
5626 PerFunctionState &PFS) {
5627 Value *V;
5628 Loc = Lex.getLoc();
5629 if (parseTypeAndValue(V, PFS))
5630 return true;
5631 if (!isa<BasicBlock>(V))
5632 return error(Loc, "expected a basic block");
5633 BB = cast<BasicBlock>(V);
5634 return false;
5635}
5636
5637/// FunctionHeader
5638/// ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
5639/// OptionalCallingConv OptRetAttrs OptUnnamedAddr Type GlobalName
5640/// '(' ArgList ')' OptAddrSpace OptFuncAttrs OptSection OptionalAlign
5641/// OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
5642bool LLParser::parseFunctionHeader(Function *&Fn, bool IsDefine) {
5643 // parse the linkage.
5644 LocTy LinkageLoc = Lex.getLoc();
5645 unsigned Linkage;
5646 unsigned Visibility;
5647 unsigned DLLStorageClass;
5648 bool DSOLocal;
5649 AttrBuilder RetAttrs;
5650 unsigned CC;
5651 bool HasLinkage;
5652 Type *RetType = nullptr;
5653 LocTy RetTypeLoc = Lex.getLoc();
5654 if (parseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass,
5655 DSOLocal) ||
5656 parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
5657 parseType(RetType, RetTypeLoc, true /*void allowed*/))
5658 return true;
5659
5660 // Verify that the linkage is ok.
5661 switch ((GlobalValue::LinkageTypes)Linkage) {
5662 case GlobalValue::ExternalLinkage:
5663 break; // always ok.
5664 case GlobalValue::ExternalWeakLinkage:
5665 if (IsDefine)
5666 return error(LinkageLoc, "invalid linkage for function definition");
5667 break;
5668 case GlobalValue::PrivateLinkage:
5669 case GlobalValue::InternalLinkage:
5670 case GlobalValue::AvailableExternallyLinkage:
5671 case GlobalValue::LinkOnceAnyLinkage:
5672 case GlobalValue::LinkOnceODRLinkage:
5673 case GlobalValue::WeakAnyLinkage:
5674 case GlobalValue::WeakODRLinkage:
5675 if (!IsDefine)
5676 return error(LinkageLoc, "invalid linkage for function declaration");
5677 break;
5678 case GlobalValue::AppendingLinkage:
5679 case GlobalValue::CommonLinkage:
5680 return error(LinkageLoc, "invalid function linkage type");
5681 }
5682
5683 if (!isValidVisibilityForLinkage(Visibility, Linkage))
5684 return error(LinkageLoc,
5685 "symbol with local linkage must have default visibility");
5686
5687 if (!FunctionType::isValidReturnType(RetType))
5688 return error(RetTypeLoc, "invalid function return type");
5689
5690 LocTy NameLoc = Lex.getLoc();
5691
5692 std::string FunctionName;
5693 if (Lex.getKind() == lltok::GlobalVar) {
5694 FunctionName = Lex.getStrVal();
5695 } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
5696 unsigned NameID = Lex.getUIntVal();
5697
5698 if (NameID != NumberedVals.size())
5699 return tokError("function expected to be numbered '%" +
5700 Twine(NumberedVals.size()) + "'");
5701 } else {
5702 return tokError("expected function name");
5703 }
5704
5705 Lex.Lex();
5706
5707 if (Lex.getKind() != lltok::lparen)
5708 return tokError("expected '(' in function argument list");
5709
5710 SmallVector<ArgInfo, 8> ArgList;
5711 bool IsVarArg;
5712 AttrBuilder FuncAttrs;
5713 std::vector<unsigned> FwdRefAttrGrps;
5714 LocTy BuiltinLoc;
5715 std::string Section;
5716 std::string Partition;
5717 MaybeAlign Alignment;
5718 std::string GC;
5719 GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
5720 unsigned AddrSpace = 0;
5721 Constant *Prefix = nullptr;
5722 Constant *Prologue = nullptr;
5723 Constant *PersonalityFn = nullptr;
5724 Comdat *C;
5725
5726 if (parseArgumentList(ArgList, IsVarArg) ||
5727 parseOptionalUnnamedAddr(UnnamedAddr) ||
5728 parseOptionalProgramAddrSpace(AddrSpace) ||
5729 parseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
5730 BuiltinLoc) ||
5731 (EatIfPresent(lltok::kw_section) && parseStringConstant(Section)) ||
5732 (EatIfPresent(lltok::kw_partition) && parseStringConstant(Partition)) ||
5733 parseOptionalComdat(FunctionName, C) ||
5734 parseOptionalAlignment(Alignment) ||
5735 (EatIfPresent(lltok::kw_gc) && parseStringConstant(GC)) ||
5736 (EatIfPresent(lltok::kw_prefix) && parseGlobalTypeAndValue(Prefix)) ||
5737 (EatIfPresent(lltok::kw_prologue) && parseGlobalTypeAndValue(Prologue)) ||
5738 (EatIfPresent(lltok::kw_personality) &&
5739 parseGlobalTypeAndValue(PersonalityFn)))
5740 return true;
5741
5742 if (FuncAttrs.contains(Attribute::Builtin))
5743 return error(BuiltinLoc, "'builtin' attribute not valid on function");
5744
5745 // If the alignment was parsed as an attribute, move to the alignment field.
5746 if (FuncAttrs.hasAlignmentAttr()) {
5747 Alignment = FuncAttrs.getAlignment();
5748 FuncAttrs.removeAttribute(Attribute::Alignment);
5749 }
5750
5751 // Okay, if we got here, the function is syntactically valid. Convert types
5752 // and do semantic checks.
5753 std::vector<Type*> ParamTypeList;
5754 SmallVector<AttributeSet, 8> Attrs;
5755
5756 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
5757 ParamTypeList.push_back(ArgList[i].Ty);
5758 Attrs.push_back(ArgList[i].Attrs);
5759 }
5760
5761 AttributeList PAL =
5762 AttributeList::get(Context, AttributeSet::get(Context, FuncAttrs),
5763 AttributeSet::get(Context, RetAttrs), Attrs);
5764
5765 if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
5766 return error(RetTypeLoc, "functions with 'sret' argument must return void");
5767
5768 FunctionType *FT = FunctionType::get(RetType, ParamTypeList, IsVarArg);
5769 PointerType *PFT = PointerType::get(FT, AddrSpace);
5770
5771 Fn = nullptr;
5772 if (!FunctionName.empty()) {
5773 // If this was a definition of a forward reference, remove the definition
5774 // from the forward reference table and fill in the forward ref.
5775 auto FRVI = ForwardRefVals.find(FunctionName);
5776 if (FRVI != ForwardRefVals.end()) {
5777 Fn = M->getFunction(FunctionName);
5778 if (!Fn)
5779 return error(FRVI->second.second, "invalid forward reference to "
5780 "function as global value!");
5781 if (Fn->getType() != PFT)
5782 return error(FRVI->second.second,
5783 "invalid forward reference to "
5784 "function '" +
5785 FunctionName +
5786 "' with wrong type: "
5787 "expected '" +
5788 getTypeString(PFT) + "' but was '" +
5789 getTypeString(Fn->getType()) + "'");
5790 ForwardRefVals.erase(FRVI);
5791 } else if ((Fn = M->getFunction(FunctionName))) {
5792 // Reject redefinitions.
5793 return error(NameLoc,
5794 "invalid redefinition of function '" + FunctionName + "'");
5795 } else if (M->getNamedValue(FunctionName)) {
5796 return error(NameLoc, "redefinition of function '@" + FunctionName + "'");
5797 }
5798
5799 } else {
5800 // If this is a definition of a forward referenced function, make sure the
5801 // types agree.
5802 auto I = ForwardRefValIDs.find(NumberedVals.size());
5803 if (I != ForwardRefValIDs.end()) {
5804 Fn = cast<Function>(I->second.first);
5805 if (Fn->getType() != PFT)
5806 return error(NameLoc, "type of definition and forward reference of '@" +
5807 Twine(NumberedVals.size()) +
5808 "' disagree: "
5809 "expected '" +
5810 getTypeString(PFT) + "' but was '" +
5811 getTypeString(Fn->getType()) + "'");
5812 ForwardRefValIDs.erase(I);
5813 }
5814 }
5815
5816 if (!Fn)
5817 Fn = Function::Create(FT, GlobalValue::ExternalLinkage, AddrSpace,
5818 FunctionName, M);
5819 else // Move the forward-reference to the correct spot in the module.
5820 M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
5821
5822 assert(Fn->getAddressSpace() == AddrSpace && "Created function in wrong AS");
5823
5824 if (FunctionName.empty())
5825 NumberedVals.push_back(Fn);
5826
5827 Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
5828 maybeSetDSOLocal(DSOLocal, *Fn);
5829 Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
5830 Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
5831 Fn->setCallingConv(CC);
5832 Fn->setAttributes(PAL);
5833 Fn->setUnnamedAddr(UnnamedAddr);
5834 Fn->setAlignment(MaybeAlign(Alignment));
5835 Fn->setSection(Section);
5836 Fn->setPartition(Partition);
5837 Fn->setComdat(C);
5838 Fn->setPersonalityFn(PersonalityFn);
5839 if (!GC.empty()) Fn->setGC(GC);
5840 Fn->setPrefixData(Prefix);
5841 Fn->setPrologueData(Prologue);
5842 ForwardRefAttrGroups[Fn] = FwdRefAttrGrps;
5843
5844 // Add all of the arguments we parsed to the function.
5845 Function::arg_iterator ArgIt = Fn->arg_begin();
5846 for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
5847 // If the argument has a name, insert it into the argument symbol table.
5848 if (ArgList[i].Name.empty()) continue;
5849
5850 // Set the name, if it conflicted, it will be auto-renamed.
5851 ArgIt->setName(ArgList[i].Name);
5852
5853 if (ArgIt->getName() != ArgList[i].Name)
5854 return error(ArgList[i].Loc,
5855 "redefinition of argument '%" + ArgList[i].Name + "'");
5856 }
5857
5858 if (IsDefine)
5859 return false;
5860
5861 // Check the declaration has no block address forward references.
5862 ValID ID;
5863 if (FunctionName.empty()) {
5864 ID.Kind = ValID::t_GlobalID;
5865 ID.UIntVal = NumberedVals.size() - 1;
5866 } else {
5867 ID.Kind = ValID::t_GlobalName;
5868 ID.StrVal = FunctionName;
5869 }
5870 auto Blocks = ForwardRefBlockAddresses.find(ID);
5871 if (Blocks != ForwardRefBlockAddresses.end())
5872 return error(Blocks->first.Loc,
5873 "cannot take blockaddress inside a declaration");
5874 return false;
5875}
5876
5877bool LLParser::PerFunctionState::resolveForwardRefBlockAddresses() {
5878 ValID ID;
5879 if (FunctionNumber == -1) {
5880 ID.Kind = ValID::t_GlobalName;
5881 ID.StrVal = std::string(F.getName());
5882 } else {
5883 ID.Kind = ValID::t_GlobalID;
5884 ID.UIntVal = FunctionNumber;
5885 }
5886
5887 auto Blocks = P.ForwardRefBlockAddresses.find(ID);
5888 if (Blocks == P.ForwardRefBlockAddresses.end())
5889 return false;
5890
5891 for (const auto &I : Blocks->second) {
5892 const ValID &BBID = I.first;
5893 GlobalValue *GV = I.second;
5894
5895 assert((BBID.Kind == ValID::t_LocalID || BBID.Kind == ValID::t_LocalName) &&
5896 "Expected local id or name");
5897 BasicBlock *BB;
5898 if (BBID.Kind == ValID::t_LocalName)
5899 BB = getBB(BBID.StrVal, BBID.Loc);
5900 else
5901 BB = getBB(BBID.UIntVal, BBID.Loc);
5902 if (!BB)
5903 return P.error(BBID.Loc, "referenced value is not a basic block");
5904
5905 GV->replaceAllUsesWith(BlockAddress::get(&F, BB));
5906 GV->eraseFromParent();
5907 }
5908
5909 P.ForwardRefBlockAddresses.erase(Blocks);
5910 return false;
5911}
5912
5913/// parseFunctionBody
5914/// ::= '{' BasicBlock+ UseListOrderDirective* '}'
5915bool LLParser::parseFunctionBody(Function &Fn) {
5916 if (Lex.getKind() != lltok::lbrace)
5917 return tokError("expected '{' in function body");
5918 Lex.Lex(); // eat the {.
5919
5920 int FunctionNumber = -1;
5921 if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
5922
5923 PerFunctionState PFS(*this, Fn, FunctionNumber);
5924
5925 // Resolve block addresses and allow basic blocks to be forward-declared
5926 // within this function.
5927 if (PFS.resolveForwardRefBlockAddresses())
5928 return true;
5929 SaveAndRestore<PerFunctionState *> ScopeExit(BlockAddressPFS, &PFS);
5930
5931 // We need at least one basic block.
5932 if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_uselistorder)
5933 return tokError("function body requires at least one basic block");
5934
5935 while (Lex.getKind() != lltok::rbrace &&
5936 Lex.getKind() != lltok::kw_uselistorder)
5937 if (parseBasicBlock(PFS))
5938 return true;
5939
5940 while (Lex.getKind() != lltok::rbrace)
5941 if (parseUseListOrder(&PFS))
5942 return true;
5943
5944 // Eat the }.
5945 Lex.Lex();
5946
5947 // Verify function is ok.
5948 return PFS.finishFunction();
5949}
5950
5951/// parseBasicBlock
5952/// ::= (LabelStr|LabelID)? Instruction*
5953bool LLParser::parseBasicBlock(PerFunctionState &PFS) {
5954 // If this basic block starts out with a name, remember it.
5955 std::string Name;
5956 int NameID = -1;
5957 LocTy NameLoc = Lex.getLoc();
5958 if (Lex.getKind() == lltok::LabelStr) {
5959 Name = Lex.getStrVal();
5960 Lex.Lex();
5961 } else if (Lex.getKind() == lltok::LabelID) {
5962 NameID = Lex.getUIntVal();
5963 Lex.Lex();
5964 }
5965
5966 BasicBlock *BB = PFS.defineBB(Name, NameID, NameLoc);
5967 if (!BB)
5968 return true;
5969
5970 std::string NameStr;
5971
5972 // parse the instructions in this block until we get a terminator.
5973 Instruction *Inst;
5974 do {
5975 // This instruction may have three possibilities for a name: a) none
5976 // specified, b) name specified "%foo =", c) number specified: "%4 =".
5977 LocTy NameLoc = Lex.getLoc();
5978 int NameID = -1;
5979 NameStr = "";
5980
5981 if (Lex.getKind() == lltok::LocalVarID) {
5982 NameID = Lex.getUIntVal();
5983 Lex.Lex();
5984 if (parseToken(lltok::equal, "expected '=' after instruction id"))
5985 return true;
5986 } else if (Lex.getKind() == lltok::LocalVar) {
5987 NameStr = Lex.getStrVal();
5988 Lex.Lex();
5989 if (parseToken(lltok::equal, "expected '=' after instruction name"))
5990 return true;
5991 }
5992
5993 switch (parseInstruction(Inst, BB, PFS)) {
5994 default:
5995 llvm_unreachable("Unknown parseInstruction result!");
5996 case InstError: return true;
5997 case InstNormal:
5998 BB->getInstList().push_back(Inst);
5999
6000 // With a normal result, we check to see if the instruction is followed by
6001 // a comma and metadata.
6002 if (EatIfPresent(lltok::comma))
6003 if (parseInstructionMetadata(*Inst))
6004 return true;
6005 break;
6006 case InstExtraComma:
6007 BB->getInstList().push_back(Inst);
6008
6009 // If the instruction parser ate an extra comma at the end of it, it
6010 // *must* be followed by metadata.
6011 if (parseInstructionMetadata(*Inst))
6012 return true;
6013 break;
6014 }
6015
6016 // Set the name on the instruction.
6017 if (PFS.setInstName(NameID, NameStr, NameLoc, Inst))
6018 return true;
6019 } while (!Inst->isTerminator());
6020
6021 return false;
6022}
6023
6024//===----------------------------------------------------------------------===//
6025// Instruction Parsing.
6026//===----------------------------------------------------------------------===//
6027
6028/// parseInstruction - parse one of the many different instructions.
6029///
6030int LLParser::parseInstruction(Instruction *&Inst, BasicBlock *BB,
6031 PerFunctionState &PFS) {
6032 lltok::Kind Token = Lex.getKind();
6033 if (Token == lltok::Eof)
6034 return tokError("found end of file when expecting more instructions");
6035 LocTy Loc = Lex.getLoc();
6036 unsigned KeywordVal = Lex.getUIntVal();
6037 Lex.Lex(); // Eat the keyword.
6038
6039 switch (Token) {
6040 default:
6041 return error(Loc, "expected instruction opcode");
6042 // Terminator Instructions.
6043 case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
6044 case lltok::kw_ret:
6045 return parseRet(Inst, BB, PFS);
6046 case lltok::kw_br:
6047 return parseBr(Inst, PFS);
6048 case lltok::kw_switch:
6049 return parseSwitch(Inst, PFS);
6050 case lltok::kw_indirectbr:
6051 return parseIndirectBr(Inst, PFS);
6052 case lltok::kw_invoke:
6053 return parseInvoke(Inst, PFS);
6054 case lltok::kw_resume:
6055 return parseResume(Inst, PFS);
6056 case lltok::kw_cleanupret:
6057 return parseCleanupRet(Inst, PFS);
6058 case lltok::kw_catchret:
6059 return parseCatchRet(Inst, PFS);
6060 case lltok::kw_catchswitch:
6061 return parseCatchSwitch(Inst, PFS);
6062 case lltok::kw_catchpad:
6063 return parseCatchPad(Inst, PFS);
6064 case lltok::kw_cleanuppad:
6065 return parseCleanupPad(Inst, PFS);
6066 case lltok::kw_callbr:
6067 return parseCallBr(Inst, PFS);
6068 // Unary Operators.
6069 case lltok::kw_fneg: {
6070 FastMathFlags FMF = EatFastMathFlagsIfPresent();
6071 int Res = parseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/ true);
6072 if (Res != 0)
6073 return Res;
6074 if (FMF.any())
6075 Inst->setFastMathFlags(FMF);
6076 return false;
6077 }
6078 // Binary Operators.
6079 case lltok::kw_add:
6080 case lltok::kw_sub:
6081 case lltok::kw_mul:
6082 case lltok::kw_shl: {
6083 bool NUW = EatIfPresent(lltok::kw_nuw);
6084 bool NSW = EatIfPresent(lltok::kw_nsw);
6085 if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
6086
6087 if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
6088 return true;
6089
6090 if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
6091 if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
6092 return false;
6093 }
6094 case lltok::kw_fadd:
6095 case lltok::kw_fsub:
6096 case lltok::kw_fmul:
6097 case lltok::kw_fdiv:
6098 case lltok::kw_frem: {
6099 FastMathFlags FMF = EatFastMathFlagsIfPresent();
6100 int Res = parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ true);
6101 if (Res != 0)
6102 return Res;
6103 if (FMF.any())
6104 Inst->setFastMathFlags(FMF);
6105 return 0;
6106 }
6107
6108 case lltok::kw_sdiv:
6109 case lltok::kw_udiv:
6110 case lltok::kw_lshr:
6111 case lltok::kw_ashr: {
6112 bool Exact = EatIfPresent(lltok::kw_exact);
6113
6114 if (parseArithmetic(Inst, PFS, KeywordVal, /*IsFP*/ false))
6115 return true;
6116 if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
6117 return false;
6118 }
6119
6120 case lltok::kw_urem:
6121 case lltok::kw_srem:
6122 return parseArithmetic(Inst, PFS, KeywordVal,
6123 /*IsFP*/ false);
6124 case lltok::kw_and:
6125 case lltok::kw_or:
6126 case lltok::kw_xor:
6127 return parseLogical(Inst, PFS, KeywordVal);
6128 case lltok::kw_icmp:
6129 return parseCompare(Inst, PFS, KeywordVal);
6130 case lltok::kw_fcmp: {
6131 FastMathFlags FMF = EatFastMathFlagsIfPresent();
6132 int Res = parseCompare(Inst, PFS, KeywordVal);
6133 if (Res != 0)
6134 return Res;
6135 if (FMF.any())
6136 Inst->setFastMathFlags(FMF);
6137 return 0;
6138 }
6139
6140 // Casts.
6141 case lltok::kw_trunc:
6142 case lltok::kw_zext:
6143 case lltok::kw_sext:
6144 case lltok::kw_fptrunc:
6145 case lltok::kw_fpext:
6146 case lltok::kw_bitcast:
6147 case lltok::kw_addrspacecast:
6148 case lltok::kw_uitofp:
6149 case lltok::kw_sitofp:
6150 case lltok::kw_fptoui:
6151 case lltok::kw_fptosi:
6152 case lltok::kw_inttoptr:
6153 case lltok::kw_ptrtoint:
6154 return parseCast(Inst, PFS, KeywordVal);
6155 // Other.
6156 case lltok::kw_select: {
6157 FastMathFlags FMF = EatFastMathFlagsIfPresent();
6158 int Res = parseSelect(Inst, PFS);
6159 if (Res != 0)
6160 return Res;
6161 if (FMF.any()) {
6162 if (!isa<FPMathOperator>(Inst))
6163 return error(Loc, "fast-math-flags specified for select without "
6164 "floating-point scalar or vector return type");
6165 Inst->setFastMathFlags(FMF);
6166 }
6167 return 0;
6168 }
6169 case lltok::kw_va_arg:
6170 return parseVAArg(Inst, PFS);
6171 case lltok::kw_extractelement:
6172 return parseExtractElement(Inst, PFS);
6173 case lltok::kw_insertelement:
6174 return parseInsertElement(Inst, PFS);
6175 case lltok::kw_shufflevector:
6176 return parseShuffleVector(Inst, PFS);
6177 case lltok::kw_phi: {
6178 FastMathFlags FMF = EatFastMathFlagsIfPresent();
6179 int Res = parsePHI(Inst, PFS);
6180 if (Res != 0)
6181 return Res;
6182 if (FMF.any()) {
6183 if (!isa<FPMathOperator>(Inst))
6184 return error(Loc, "fast-math-flags specified for phi without "
6185 "floating-point scalar or vector return type");
6186 Inst->setFastMathFlags(FMF);
6187 }
6188 return 0;
6189 }
6190 case lltok::kw_landingpad:
6191 return parseLandingPad(Inst, PFS);
6192 case lltok::kw_freeze:
6193 return parseFreeze(Inst, PFS);
6194 // Call.
6195 case lltok::kw_call:
6196 return parseCall(Inst, PFS, CallInst::TCK_None);
6197 case lltok::kw_tail:
6198 return parseCall(Inst, PFS, CallInst::TCK_Tail);
6199 case lltok::kw_musttail:
6200 return parseCall(Inst, PFS, CallInst::TCK_MustTail);
6201 case lltok::kw_notail:
6202 return parseCall(Inst, PFS, CallInst::TCK_NoTail);
6203 // Memory.
6204 case lltok::kw_alloca:
6205 return parseAlloc(Inst, PFS);
6206 case lltok::kw_load:
6207 return parseLoad(Inst, PFS);
6208 case lltok::kw_store:
6209 return parseStore(Inst, PFS);
6210 case lltok::kw_cmpxchg:
6211 return parseCmpXchg(Inst, PFS);
6212 case lltok::kw_atomicrmw:
6213 return parseAtomicRMW(Inst, PFS);
6214 case lltok::kw_fence:
6215 return parseFence(Inst, PFS);
6216 case lltok::kw_getelementptr:
6217 return parseGetElementPtr(Inst, PFS);
6218 case lltok::kw_extractvalue:
6219 return parseExtractValue(Inst, PFS);
6220 case lltok::kw_insertvalue:
6221 return parseInsertValue(Inst, PFS);
6222 }
6223}
6224
6225/// parseCmpPredicate - parse an integer or fp predicate, based on Kind.
6226bool LLParser::parseCmpPredicate(unsigned &P, unsigned Opc) {
6227 if (Opc == Instruction::FCmp) {
6228 switch (Lex.getKind()) {
6229 default:
6230 return tokError("expected fcmp predicate (e.g. 'oeq')");
6231 case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
6232 case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
6233 case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
6234 case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
6235 case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
6236 case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
6237 case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
6238 case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
6239 case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
6240 case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
6241 case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
6242 case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
6243 case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
6244 case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
6245 case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
6246 case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
6247 }
6248 } else {
6249 switch (Lex.getKind()) {
6250 default:
6251 return tokError("expected icmp predicate (e.g. 'eq')");
6252 case lltok::kw_eq: P = CmpInst::ICMP_EQ; break;
6253 case lltok::kw_ne: P = CmpInst::ICMP_NE; break;
6254 case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
6255 case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
6256 case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
6257 case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
6258 case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
6259 case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
6260 case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
6261 case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
6262 }
6263 }
6264 Lex.Lex();
6265 return false;
6266}
6267
6268//===----------------------------------------------------------------------===//
6269// Terminator Instructions.
6270//===----------------------------------------------------------------------===//
6271
6272/// parseRet - parse a return instruction.
6273/// ::= 'ret' void (',' !dbg, !1)*
6274/// ::= 'ret' TypeAndValue (',' !dbg, !1)*
6275bool LLParser::parseRet(Instruction *&Inst, BasicBlock *BB,
6276 PerFunctionState &PFS) {
6277 SMLoc TypeLoc = Lex.getLoc();
6278 Type *Ty = nullptr;
6279 if (parseType(Ty, true /*void allowed*/))
6280 return true;
6281
6282 Type *ResType = PFS.getFunction().getReturnType();
6283
6284 if (Ty->isVoidTy()) {
6285 if (!ResType->isVoidTy())
6286 return error(TypeLoc, "value doesn't match function result type '" +
6287 getTypeString(ResType) + "'");
6288
6289 Inst = ReturnInst::Create(Context);
6290 return false;
6291 }
6292
6293 Value *RV;
6294 if (parseValue(Ty, RV, PFS))
6295 return true;
6296
6297 if (ResType != RV->getType())
6298 return error(TypeLoc, "value doesn't match function result type '" +
6299 getTypeString(ResType) + "'");
6300
6301 Inst = ReturnInst::Create(Context, RV);
6302 return false;
6303}
6304
6305/// parseBr
6306/// ::= 'br' TypeAndValue
6307/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
6308bool LLParser::parseBr(Instruction *&Inst, PerFunctionState &PFS) {
6309 LocTy Loc, Loc2;
6310 Value *Op0;
6311 BasicBlock *Op1, *Op2;
6312 if (parseTypeAndValue(Op0, Loc, PFS))
6313 return true;
6314
6315 if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
6316 Inst = BranchInst::Create(BB);
6317 return false;
6318 }
6319
6320 if (Op0->getType() != Type::getInt1Ty(Context))
6321 return error(Loc, "branch condition must have 'i1' type");
6322
6323 if (parseToken(lltok::comma, "expected ',' after branch condition") ||
6324 parseTypeAndBasicBlock(Op1, Loc, PFS) ||
6325 parseToken(lltok::comma, "expected ',' after true destination") ||
6326 parseTypeAndBasicBlock(Op2, Loc2, PFS))
6327 return true;
6328
6329 Inst = BranchInst::Create(Op1, Op2, Op0);
6330 return false;
6331}
6332
6333/// parseSwitch
6334/// Instruction
6335/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
6336/// JumpTable
6337/// ::= (TypeAndValue ',' TypeAndValue)*
6338bool LLParser::parseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
6339 LocTy CondLoc, BBLoc;
6340 Value *Cond;
6341 BasicBlock *DefaultBB;
6342 if (parseTypeAndValue(Cond, CondLoc, PFS) ||
6343 parseToken(lltok::comma, "expected ',' after switch condition") ||
6344 parseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
6345 parseToken(lltok::lsquare, "expected '[' with switch table"))
6346 return true;
6347
6348 if (!Cond->getType()->isIntegerTy())
6349 return error(CondLoc, "switch condition must have integer type");
6350
6351 // parse the jump table pairs.
6352 SmallPtrSet<Value*, 32> SeenCases;
6353 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
6354 while (Lex.getKind() != lltok::rsquare) {
6355 Value *Constant;
6356 BasicBlock *DestBB;
6357
6358 if (parseTypeAndValue(Constant, CondLoc, PFS) ||
6359 parseToken(lltok::comma, "expected ',' after case value") ||
6360 parseTypeAndBasicBlock(DestBB, PFS))
6361 return true;
6362
6363 if (!SeenCases.insert(Constant).second)
6364 return error(CondLoc, "duplicate case value in switch");
6365 if (!isa<ConstantInt>(Constant))
6366 return error(CondLoc, "case value is not a constant integer");
6367
6368 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
6369 }
6370
6371 Lex.Lex(); // Eat the ']'.
6372
6373 SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
6374 for (unsigned i = 0, e = Table.size(); i != e; ++i)
6375 SI->addCase(Table[i].first, Table[i].second);
6376 Inst = SI;
6377 return false;
6378}
6379
6380/// parseIndirectBr
6381/// Instruction
6382/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
6383bool LLParser::parseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
6384 LocTy AddrLoc;
6385 Value *Address;
6386 if (parseTypeAndValue(Address, AddrLoc, PFS) ||
6387 parseToken(lltok::comma, "expected ',' after indirectbr address") ||
6388 parseToken(lltok::lsquare, "expected '[' with indirectbr"))
6389 return true;
6390
6391 if (!Address->getType()->isPointerTy())
6392 return error(AddrLoc, "indirectbr address must have pointer type");
6393
6394 // parse the destination list.
6395 SmallVector<BasicBlock*, 16> DestList;
6396
6397 if (Lex.getKind() != lltok::rsquare) {
6398 BasicBlock *DestBB;
6399 if (parseTypeAndBasicBlock(DestBB, PFS))
6400 return true;
6401 DestList.push_back(DestBB);
6402
6403 while (EatIfPresent(lltok::comma)) {
6404 if (parseTypeAndBasicBlock(DestBB, PFS))
6405 return true;
6406 DestList.push_back(DestBB);
6407 }
6408 }
6409
6410 if (parseToken(lltok::rsquare, "expected ']' at end of block list"))
6411 return true;
6412
6413 IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
6414 for (unsigned i = 0, e = DestList.size(); i != e; ++i)
6415 IBI->addDestination(DestList[i]);
6416 Inst = IBI;
6417 return false;
6418}
6419
6420/// parseInvoke
6421/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
6422/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
6423bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
6424 LocTy CallLoc = Lex.getLoc();
6425 AttrBuilder RetAttrs, FnAttrs;
6426 std::vector<unsigned> FwdRefAttrGrps;
6427 LocTy NoBuiltinLoc;
6428 unsigned CC;
6429 unsigned InvokeAddrSpace;
6430 Type *RetType = nullptr;
6431 LocTy RetTypeLoc;
6432 ValID CalleeID;
6433 SmallVector<ParamInfo, 16> ArgList;
6434 SmallVector<OperandBundleDef, 2> BundleList;
6435
6436 BasicBlock *NormalBB, *UnwindBB;
6437 if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
6438 parseOptionalProgramAddrSpace(InvokeAddrSpace) ||
6439 parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
6440 parseValID(CalleeID) || parseParameterList(ArgList, PFS) ||
6441 parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
6442 NoBuiltinLoc) ||
6443 parseOptionalOperandBundles(BundleList, PFS) ||
6444 parseToken(lltok::kw_to, "expected 'to' in invoke") ||
6445 parseTypeAndBasicBlock(NormalBB, PFS) ||
6446 parseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
6447 parseTypeAndBasicBlock(UnwindBB, PFS))
6448 return true;
6449
6450 // If RetType is a non-function pointer type, then this is the short syntax
6451 // for the call, which means that RetType is just the return type. Infer the
6452 // rest of the function argument types from the arguments that are present.
6453 FunctionType *Ty = dyn_cast<FunctionType>(RetType);
6454 if (!Ty) {
6455 // Pull out the types of all of the arguments...
6456 std::vector<Type*> ParamTypes;
6457 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
6458 ParamTypes.push_back(ArgList[i].V->getType());
6459
6460 if (!FunctionType::isValidReturnType(RetType))
6461 return error(RetTypeLoc, "Invalid result type for LLVM function");
6462
6463 Ty = FunctionType::get(RetType, ParamTypes, false);
6464 }
6465
6466 CalleeID.FTy = Ty;
6467
6468 // Look up the callee.
6469 Value *Callee;
6470 if (convertValIDToValue(PointerType::get(Ty, InvokeAddrSpace), CalleeID,
6471 Callee, &PFS, /*IsCall=*/true))
6472 return true;
6473
6474 // Set up the Attribute for the function.
6475 SmallVector<Value *, 8> Args;
6476 SmallVector<AttributeSet, 8> ArgAttrs;
6477
6478 // Loop through FunctionType's arguments and ensure they are specified
6479 // correctly. Also, gather any parameter attributes.
6480 FunctionType::param_iterator I = Ty->param_begin();
6481 FunctionType::param_iterator E = Ty->param_end();
6482 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
6483 Type *ExpectedTy = nullptr;
6484 if (I != E) {
6485 ExpectedTy = *I++;
6486 } else if (!Ty->isVarArg()) {
6487 return error(ArgList[i].Loc, "too many arguments specified");
6488 }
6489
6490 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
6491 return error(ArgList[i].Loc, "argument is not of expected type '" +
6492 getTypeString(ExpectedTy) + "'");
6493 Args.push_back(ArgList[i].V);
6494 ArgAttrs.push_back(ArgList[i].Attrs);
6495 }
6496
6497 if (I != E)
6498 return error(CallLoc, "not enough parameters specified for call");
6499
6500 if (FnAttrs.hasAlignmentAttr())
6501 return error(CallLoc, "invoke instructions may not have an alignment");
6502
6503 // Finish off the Attribute and check them
6504 AttributeList PAL =
6505 AttributeList::get(Context, AttributeSet::get(Context, FnAttrs),
6506 AttributeSet::get(Context, RetAttrs), ArgAttrs);
6507
6508 InvokeInst *II =
6509 InvokeInst::Create(Ty, Callee, NormalBB, UnwindBB, Args, BundleList);
6510 II->setCallingConv(CC);
6511 II->setAttributes(PAL);
6512 ForwardRefAttrGroups[II] = FwdRefAttrGrps;
6513 Inst = II;
6514 return false;
6515}
6516
6517/// parseResume
6518/// ::= 'resume' TypeAndValue
6519bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) {
6520 Value *Exn; LocTy ExnLoc;
6521 if (parseTypeAndValue(Exn, ExnLoc, PFS))
6522 return true;
6523
6524 ResumeInst *RI = ResumeInst::Create(Exn);
6525 Inst = RI;
6526 return false;
6527}
6528
6529bool LLParser::parseExceptionArgs(SmallVectorImpl<Value *> &Args,
6530 PerFunctionState &PFS) {
6531 if (parseToken(lltok::lsquare, "expected '[' in catchpad/cleanuppad"))
6532 return true;
6533
6534 while (Lex.getKind() != lltok::rsquare) {
6535 // If this isn't the first argument, we need a comma.
6536 if (!Args.empty() &&
6537 parseToken(lltok::comma, "expected ',' in argument list"))
6538 return true;
6539
6540 // parse the argument.
6541 LocTy ArgLoc;
6542 Type *ArgTy = nullptr;
6543 if (parseType(ArgTy, ArgLoc))
6544 return true;
6545
6546 Value *V;
6547 if (ArgTy->isMetadataTy()) {
6548 if (parseMetadataAsValue(V, PFS))
6549 return true;
6550 } else {
6551 if (parseValue(ArgTy, V, PFS))
6552 return true;
6553 }
6554 Args.push_back(V);
6555 }
6556
6557 Lex.Lex(); // Lex the ']'.
6558 return false;
6559}
6560
6561/// parseCleanupRet
6562/// ::= 'cleanupret' from Value unwind ('to' 'caller' | TypeAndValue)
6563bool LLParser::parseCleanupRet(Instruction *&Inst, PerFunctionState &PFS) {
6564 Value *CleanupPad = nullptr;
6565
6566 if (parseToken(lltok::kw_from, "expected 'from' after cleanupret"))
6567 return true;
6568
6569 if (parseValue(Type::getTokenTy(Context), CleanupPad, PFS))
6570 return true;
6571
6572 if (parseToken(lltok::kw_unwind, "expected 'unwind' in cleanupret"))
6573 return true;
6574
6575 BasicBlock *UnwindBB = nullptr;
6576 if (Lex.getKind() == lltok::kw_to) {
6577 Lex.Lex();
6578 if (parseToken(lltok::kw_caller, "expected 'caller' in cleanupret"))
6579 return true;
6580 } else {
6581 if (parseTypeAndBasicBlock(UnwindBB, PFS)) {
6582 return true;
6583 }
6584 }
6585
6586 Inst = CleanupReturnInst::Create(CleanupPad, UnwindBB);
6587 return false;
6588}
6589
6590/// parseCatchRet
6591/// ::= 'catchret' from Parent Value 'to' TypeAndValue
6592bool LLParser::parseCatchRet(Instruction *&Inst, PerFunctionState &PFS) {
6593 Value *CatchPad = nullptr;
6594
6595 if (parseToken(lltok::kw_from, "expected 'from' after catchret"))
6596 return true;
6597
6598 if (parseValue(Type::getTokenTy(Context), CatchPad, PFS))
6599 return true;
6600
6601 BasicBlock *BB;
6602 if (parseToken(lltok::kw_to, "expected 'to' in catchret") ||
6603 parseTypeAndBasicBlock(BB, PFS))
6604 return true;
6605
6606 Inst = CatchReturnInst::Create(CatchPad, BB);
6607 return false;
6608}
6609
6610/// parseCatchSwitch
6611/// ::= 'catchswitch' within Parent
6612bool LLParser::parseCatchSwitch(Instruction *&Inst, PerFunctionState &PFS) {
6613 Value *ParentPad;
6614
6615 if (parseToken(lltok::kw_within, "expected 'within' after catchswitch"))
6616 return true;
6617
6618 if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
6619 Lex.getKind() != lltok::LocalVarID)
6620 return tokError("expected scope value for catchswitch");
6621
6622 if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
6623 return true;
6624
6625 if (parseToken(lltok::lsquare, "expected '[' with catchswitch labels"))
6626 return true;
6627
6628 SmallVector<BasicBlock *, 32> Table;
6629 do {
6630 BasicBlock *DestBB;
6631 if (parseTypeAndBasicBlock(DestBB, PFS))
6632 return true;
6633 Table.push_back(DestBB);
6634 } while (EatIfPresent(lltok::comma));
6635
6636 if (parseToken(lltok::rsquare, "expected ']' after catchswitch labels"))
6637 return true;
6638
6639 if (parseToken(lltok::kw_unwind, "expected 'unwind' after catchswitch scope"))
6640 return true;
6641
6642 BasicBlock *UnwindBB = nullptr;
6643 if (EatIfPresent(lltok::kw_to)) {
6644 if (parseToken(lltok::kw_caller, "expected 'caller' in catchswitch"))
6645 return true;
6646 } else {
6647 if (parseTypeAndBasicBlock(UnwindBB, PFS))
6648 return true;
6649 }
6650
6651 auto *CatchSwitch =
6652 CatchSwitchInst::Create(ParentPad, UnwindBB, Table.size());
6653 for (BasicBlock *DestBB : Table)
6654 CatchSwitch->addHandler(DestBB);
6655 Inst = CatchSwitch;
6656 return false;
6657}
6658
6659/// parseCatchPad
6660/// ::= 'catchpad' ParamList 'to' TypeAndValue 'unwind' TypeAndValue
6661bool LLParser::parseCatchPad(Instruction *&Inst, PerFunctionState &PFS) {
6662 Value *CatchSwitch = nullptr;
6663
6664 if (parseToken(lltok::kw_within, "expected 'within' after catchpad"))
6665 return true;
6666
6667 if (Lex.getKind() != lltok::LocalVar && Lex.getKind() != lltok::LocalVarID)
6668 return tokError("expected scope value for catchpad");
6669
6670 if (parseValue(Type::getTokenTy(Context), CatchSwitch, PFS))
6671 return true;
6672
6673 SmallVector<Value *, 8> Args;
6674 if (parseExceptionArgs(Args, PFS))
6675 return true;
6676
6677 Inst = CatchPadInst::Create(CatchSwitch, Args);
6678 return false;
6679}
6680
6681/// parseCleanupPad
6682/// ::= 'cleanuppad' within Parent ParamList
6683bool LLParser::parseCleanupPad(Instruction *&Inst, PerFunctionState &PFS) {
6684 Value *ParentPad = nullptr;
6685
6686 if (parseToken(lltok::kw_within, "expected 'within' after cleanuppad"))
6687 return true;
6688
6689 if (Lex.getKind() != lltok::kw_none && Lex.getKind() != lltok::LocalVar &&
6690 Lex.getKind() != lltok::LocalVarID)
6691 return tokError("expected scope value for cleanuppad");
6692
6693 if (parseValue(Type::getTokenTy(Context), ParentPad, PFS))
6694 return true;
6695
6696 SmallVector<Value *, 8> Args;
6697 if (parseExceptionArgs(Args, PFS))
6698 return true;
6699
6700 Inst = CleanupPadInst::Create(ParentPad, Args);
6701 return false;
6702}
6703
6704//===----------------------------------------------------------------------===//
6705// Unary Operators.
6706//===----------------------------------------------------------------------===//
6707
6708/// parseUnaryOp
6709/// ::= UnaryOp TypeAndValue ',' Value
6710///
6711/// If IsFP is false, then any integer operand is allowed, if it is true, any fp
6712/// operand is allowed.
6713bool LLParser::parseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
6714 unsigned Opc, bool IsFP) {
6715 LocTy Loc; Value *LHS;
6716 if (parseTypeAndValue(LHS, Loc, PFS))
6717 return true;
6718
6719 bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy()
6720 : LHS->getType()->isIntOrIntVectorTy();
6721
6722 if (!Valid)
6723 return error(Loc, "invalid operand type for instruction");
6724
6725 Inst = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
6726 return false;
6727}
6728
6729/// parseCallBr
6730/// ::= 'callbr' OptionalCallingConv OptionalAttrs Type Value ParamList
6731/// OptionalAttrs OptionalOperandBundles 'to' TypeAndValue
6732/// '[' LabelList ']'
6733bool LLParser::parseCallBr(Instruction *&Inst, PerFunctionState &PFS) {
6734 LocTy CallLoc = Lex.getLoc();
6735 AttrBuilder RetAttrs, FnAttrs;
6736 std::vector<unsigned> FwdRefAttrGrps;
6737 LocTy NoBuiltinLoc;
6738 unsigned CC;
6739 Type *RetType = nullptr;
6740 LocTy RetTypeLoc;
6741 ValID CalleeID;
6742 SmallVector<ParamInfo, 16> ArgList;
6743 SmallVector<OperandBundleDef, 2> BundleList;
6744
6745 BasicBlock *DefaultDest;
6746 if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
6747 parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
6748 parseValID(CalleeID) || parseParameterList(ArgList, PFS) ||
6749 parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
6750 NoBuiltinLoc) ||
6751 parseOptionalOperandBundles(BundleList, PFS) ||
6752 parseToken(lltok::kw_to, "expected 'to' in callbr") ||
6753 parseTypeAndBasicBlock(DefaultDest, PFS) ||
6754 parseToken(lltok::lsquare, "expected '[' in callbr"))
6755 return true;
6756
6757 // parse the destination list.
6758 SmallVector<BasicBlock *, 16> IndirectDests;
6759
6760 if (Lex.getKind() != lltok::rsquare) {
6761 BasicBlock *DestBB;
6762 if (parseTypeAndBasicBlock(DestBB, PFS))
6763 return true;
6764 IndirectDests.push_back(DestBB);
6765
6766 while (EatIfPresent(lltok::comma)) {
6767 if (parseTypeAndBasicBlock(DestBB, PFS))
6768 return true;
6769 IndirectDests.push_back(DestBB);
6770 }
6771 }
6772
6773 if (parseToken(lltok::rsquare, "expected ']' at end of block list"))
6774 return true;
6775
6776 // If RetType is a non-function pointer type, then this is the short syntax
6777 // for the call, which means that RetType is just the return type. Infer the
6778 // rest of the function argument types from the arguments that are present.
6779 FunctionType *Ty = dyn_cast<FunctionType>(RetType);
6780 if (!Ty) {
6781 // Pull out the types of all of the arguments...
6782 std::vector<Type *> ParamTypes;
6783 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
6784 ParamTypes.push_back(ArgList[i].V->getType());
6785
6786 if (!FunctionType::isValidReturnType(RetType))
6787 return error(RetTypeLoc, "Invalid result type for LLVM function");
6788
6789 Ty = FunctionType::get(RetType, ParamTypes, false);
6790 }
6791
6792 CalleeID.FTy = Ty;
6793
6794 // Look up the callee.
6795 Value *Callee;
6796 if (convertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS,
6797 /*IsCall=*/true))
6798 return true;
6799
6800 // Set up the Attribute for the function.
6801 SmallVector<Value *, 8> Args;
6802 SmallVector<AttributeSet, 8> ArgAttrs;
6803
6804 // Loop through FunctionType's arguments and ensure they are specified
6805 // correctly. Also, gather any parameter attributes.
6806 FunctionType::param_iterator I = Ty->param_begin();
6807 FunctionType::param_iterator E = Ty->param_end();
6808 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
6809 Type *ExpectedTy = nullptr;
6810 if (I != E) {
6811 ExpectedTy = *I++;
6812 } else if (!Ty->isVarArg()) {
6813 return error(ArgList[i].Loc, "too many arguments specified");
6814 }
6815
6816 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
6817 return error(ArgList[i].Loc, "argument is not of expected type '" +
6818 getTypeString(ExpectedTy) + "'");
6819 Args.push_back(ArgList[i].V);
6820 ArgAttrs.push_back(ArgList[i].Attrs);
6821 }
6822
6823 if (I != E)
6824 return error(CallLoc, "not enough parameters specified for call");
6825
6826 if (FnAttrs.hasAlignmentAttr())
6827 return error(CallLoc, "callbr instructions may not have an alignment");
6828
6829 // Finish off the Attribute and check them
6830 AttributeList PAL =
6831 AttributeList::get(Context, AttributeSet::get(Context, FnAttrs),
6832 AttributeSet::get(Context, RetAttrs), ArgAttrs);
6833
6834 CallBrInst *CBI =
6835 CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
6836 BundleList);
6837 CBI->setCallingConv(CC);
6838 CBI->setAttributes(PAL);
6839 ForwardRefAttrGroups[CBI] = FwdRefAttrGrps;
6840 Inst = CBI;
6841 return false;
6842}
6843
6844//===----------------------------------------------------------------------===//
6845// Binary Operators.
6846//===----------------------------------------------------------------------===//
6847
6848/// parseArithmetic
6849/// ::= ArithmeticOps TypeAndValue ',' Value
6850///
6851/// If IsFP is false, then any integer operand is allowed, if it is true, any fp
6852/// operand is allowed.
6853bool LLParser::parseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
6854 unsigned Opc, bool IsFP) {
6855 LocTy Loc; Value *LHS, *RHS;
6856 if (parseTypeAndValue(LHS, Loc, PFS) ||
6857 parseToken(lltok::comma, "expected ',' in arithmetic operation") ||
6858 parseValue(LHS->getType(), RHS, PFS))
6859 return true;
6860
6861 bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy()
6862 : LHS->getType()->isIntOrIntVectorTy();
6863
6864 if (!Valid)
6865 return error(Loc, "invalid operand type for instruction");
6866
6867 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
6868 return false;
6869}
6870
6871/// parseLogical
6872/// ::= ArithmeticOps TypeAndValue ',' Value {
6873bool LLParser::parseLogical(Instruction *&Inst, PerFunctionState &PFS,
6874 unsigned Opc) {
6875 LocTy Loc; Value *LHS, *RHS;
6876 if (parseTypeAndValue(LHS, Loc, PFS) ||
6877 parseToken(lltok::comma, "expected ',' in logical operation") ||
6878 parseValue(LHS->getType(), RHS, PFS))
6879 return true;
6880
6881 if (!LHS->getType()->isIntOrIntVectorTy())
6882 return error(Loc,
6883 "instruction requires integer or integer vector operands");
6884
6885 Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
6886 return false;
6887}
6888
6889/// parseCompare
6890/// ::= 'icmp' IPredicates TypeAndValue ',' Value
6891/// ::= 'fcmp' FPredicates TypeAndValue ',' Value
6892bool LLParser::parseCompare(Instruction *&Inst, PerFunctionState &PFS,
6893 unsigned Opc) {
6894 // parse the integer/fp comparison predicate.
6895 LocTy Loc;
6896 unsigned Pred;
6897 Value *LHS, *RHS;
6898 if (parseCmpPredicate(Pred, Opc) || parseTypeAndValue(LHS, Loc, PFS) ||
6899 parseToken(lltok::comma, "expected ',' after compare value") ||
6900 parseValue(LHS->getType(), RHS, PFS))
6901 return true;
6902
6903 if (Opc == Instruction::FCmp) {
6904 if (!LHS->getType()->isFPOrFPVectorTy())
6905 return error(Loc, "fcmp requires floating point operands");
6906 Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
6907 } else {
6908 assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
6909 if (!LHS->getType()->isIntOrIntVectorTy() &&
6910 !LHS->getType()->isPtrOrPtrVectorTy())
6911 return error(Loc, "icmp requires integer operands");
6912 Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
6913 }
6914 return false;
6915}
6916
6917//===----------------------------------------------------------------------===//
6918// Other Instructions.
6919//===----------------------------------------------------------------------===//
6920
6921/// parseCast
6922/// ::= CastOpc TypeAndValue 'to' Type
6923bool LLParser::parseCast(Instruction *&Inst, PerFunctionState &PFS,
6924 unsigned Opc) {
6925 LocTy Loc;
6926 Value *Op;
6927 Type *DestTy = nullptr;
6928 if (parseTypeAndValue(Op, Loc, PFS) ||
6929 parseToken(lltok::kw_to, "expected 'to' after cast value") ||
6930 parseType(DestTy))
6931 return true;
6932
6933 if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
6934 CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
6935 return error(Loc, "invalid cast opcode for cast from '" +
6936 getTypeString(Op->getType()) + "' to '" +
6937 getTypeString(DestTy) + "'");
6938 }
6939 Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
6940 return false;
6941}
6942
6943/// parseSelect
6944/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
6945bool LLParser::parseSelect(Instruction *&Inst, PerFunctionState &PFS) {
6946 LocTy Loc;
6947 Value *Op0, *Op1, *Op2;
6948 if (parseTypeAndValue(Op0, Loc, PFS) ||
6949 parseToken(lltok::comma, "expected ',' after select condition") ||
6950 parseTypeAndValue(Op1, PFS) ||
6951 parseToken(lltok::comma, "expected ',' after select value") ||
6952 parseTypeAndValue(Op2, PFS))
6953 return true;
6954
6955 if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
6956 return error(Loc, Reason);
6957
6958 Inst = SelectInst::Create(Op0, Op1, Op2);
6959 return false;
6960}
6961
6962/// parseVAArg
6963/// ::= 'va_arg' TypeAndValue ',' Type
6964bool LLParser::parseVAArg(Instruction *&Inst, PerFunctionState &PFS) {
6965 Value *Op;
6966 Type *EltTy = nullptr;
6967 LocTy TypeLoc;
6968 if (parseTypeAndValue(Op, PFS) ||
6969 parseToken(lltok::comma, "expected ',' after vaarg operand") ||
6970 parseType(EltTy, TypeLoc))
6971 return true;
6972
6973 if (!EltTy->isFirstClassType())
6974 return error(TypeLoc, "va_arg requires operand with first class type");
6975
6976 Inst = new VAArgInst(Op, EltTy);
6977 return false;
6978}
6979
6980/// parseExtractElement
6981/// ::= 'extractelement' TypeAndValue ',' TypeAndValue
6982bool LLParser::parseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
6983 LocTy Loc;
6984 Value *Op0, *Op1;
6985 if (parseTypeAndValue(Op0, Loc, PFS) ||
6986 parseToken(lltok::comma, "expected ',' after extract value") ||
6987 parseTypeAndValue(Op1, PFS))
6988 return true;
6989
6990 if (!ExtractElementInst::isValidOperands(Op0, Op1))
6991 return error(Loc, "invalid extractelement operands");
6992
6993 Inst = ExtractElementInst::Create(Op0, Op1);
6994 return false;
6995}
6996
6997/// parseInsertElement
6998/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
6999bool LLParser::parseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
7000 LocTy Loc;
7001 Value *Op0, *Op1, *Op2;
7002 if (parseTypeAndValue(Op0, Loc, PFS) ||
7003 parseToken(lltok::comma, "expected ',' after insertelement value") ||
7004 parseTypeAndValue(Op1, PFS) ||
7005 parseToken(lltok::comma, "expected ',' after insertelement value") ||
7006 parseTypeAndValue(Op2, PFS))
7007 return true;
7008
7009 if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
7010 return error(Loc, "invalid insertelement operands");
7011
7012 Inst = InsertElementInst::Create(Op0, Op1, Op2);
7013 return false;
7014}
7015
7016/// parseShuffleVector
7017/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
7018bool LLParser::parseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
7019 LocTy Loc;
7020 Value *Op0, *Op1, *Op2;
7021 if (parseTypeAndValue(Op0, Loc, PFS) ||
7022 parseToken(lltok::comma, "expected ',' after shuffle mask") ||
7023 parseTypeAndValue(Op1, PFS) ||
7024 parseToken(lltok::comma, "expected ',' after shuffle value") ||
7025 parseTypeAndValue(Op2, PFS))
7026 return true;
7027
7028 if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
7029 return error(Loc, "invalid shufflevector operands");
7030
7031 Inst = new ShuffleVectorInst(Op0, Op1, Op2);
7032 return false;
7033}
7034
7035/// parsePHI
7036/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
7037int LLParser::parsePHI(Instruction *&Inst, PerFunctionState &PFS) {
7038 Type *Ty = nullptr; LocTy TypeLoc;
7039 Value *Op0, *Op1;
7040
7041 if (parseType(Ty, TypeLoc) ||
7042 parseToken(lltok::lsquare, "expected '[' in phi value list") ||
7043 parseValue(Ty, Op0, PFS) ||
7044 parseToken(lltok::comma, "expected ',' after insertelement value") ||
7045 parseValue(Type::getLabelTy(Context), Op1, PFS) ||
7046 parseToken(lltok::rsquare, "expected ']' in phi value list"))
7047 return true;
7048
7049 bool AteExtraComma = false;
7050 SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
7051
7052 while (true) {
7053 PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
7054
7055 if (!EatIfPresent(lltok::comma))
7056 break;
7057
7058 if (Lex.getKind() == lltok::MetadataVar) {
7059 AteExtraComma = true;
7060 break;
7061 }
7062
7063 if (parseToken(lltok::lsquare, "expected '[' in phi value list") ||
7064 parseValue(Ty, Op0, PFS) ||
7065 parseToken(lltok::comma, "expected ',' after insertelement value") ||
7066 parseValue(Type::getLabelTy(Context), Op1, PFS) ||
7067 parseToken(lltok::rsquare, "expected ']' in phi value list"))
7068 return true;
7069 }
7070
7071 if (!Ty->isFirstClassType())
7072 return error(TypeLoc, "phi node must have first class type");
7073
7074 PHINode *PN = PHINode::Create(Ty, PHIVals.size());
7075 for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
7076 PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
7077 Inst = PN;
7078 return AteExtraComma ? InstExtraComma : InstNormal;
7079}
7080
7081/// parseLandingPad
7082/// ::= 'landingpad' Type 'personality' TypeAndValue 'cleanup'? Clause+
7083/// Clause
7084/// ::= 'catch' TypeAndValue
7085/// ::= 'filter'
7086/// ::= 'filter' TypeAndValue ( ',' TypeAndValue )*
7087bool LLParser::parseLandingPad(Instruction *&Inst, PerFunctionState &PFS) {
7088 Type *Ty = nullptr; LocTy TyLoc;
7089
7090 if (parseType(Ty, TyLoc))
7091 return true;
7092
7093 std::unique_ptr<LandingPadInst> LP(LandingPadInst::Create(Ty, 0));
7094 LP->setCleanup(EatIfPresent(lltok::kw_cleanup));
7095
7096 while (Lex.getKind() == lltok::kw_catch || Lex.getKind() == lltok::kw_filter){
7097 LandingPadInst::ClauseType CT;
7098 if (EatIfPresent(lltok::kw_catch))
7099 CT = LandingPadInst::Catch;
7100 else if (EatIfPresent(lltok::kw_filter))
7101 CT = LandingPadInst::Filter;
7102 else
7103 return tokError("expected 'catch' or 'filter' clause type");
7104
7105 Value *V;
7106 LocTy VLoc;
7107 if (parseTypeAndValue(V, VLoc, PFS))
7108 return true;
7109
7110 // A 'catch' type expects a non-array constant. A filter clause expects an
7111 // array constant.
7112 if (CT == LandingPadInst::Catch) {
7113 if (isa<ArrayType>(V->getType()))
7114 error(VLoc, "'catch' clause has an invalid type");
7115 } else {
7116 if (!isa<ArrayType>(V->getType()))
7117 error(VLoc, "'filter' clause has an invalid type");
7118 }
7119
7120 Constant *CV = dyn_cast<Constant>(V);
7121 if (!CV)
7122 return error(VLoc, "clause argument must be a constant");
7123 LP->addClause(CV);
7124 }
7125
7126 Inst = LP.release();
7127 return false;
7128}
7129
7130/// parseFreeze
7131/// ::= 'freeze' Type Value
7132bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) {
7133 LocTy Loc;
7134 Value *Op;
7135 if (parseTypeAndValue(Op, Loc, PFS))
7136 return true;
7137
7138 Inst = new FreezeInst(Op);
7139 return false;
7140}
7141
7142/// parseCall
7143/// ::= 'call' OptionalFastMathFlags OptionalCallingConv
7144/// OptionalAttrs Type Value ParameterList OptionalAttrs
7145/// ::= 'tail' 'call' OptionalFastMathFlags OptionalCallingConv
7146/// OptionalAttrs Type Value ParameterList OptionalAttrs
7147/// ::= 'musttail' 'call' OptionalFastMathFlags OptionalCallingConv
7148/// OptionalAttrs Type Value ParameterList OptionalAttrs
7149/// ::= 'notail' 'call' OptionalFastMathFlags OptionalCallingConv
7150/// OptionalAttrs Type Value ParameterList OptionalAttrs
7151bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
7152 CallInst::TailCallKind TCK) {
7153 AttrBuilder RetAttrs, FnAttrs;
7154 std::vector<unsigned> FwdRefAttrGrps;
7155 LocTy BuiltinLoc;
7156 unsigned CallAddrSpace;
7157 unsigned CC;
7158 Type *RetType = nullptr;
7159 LocTy RetTypeLoc;
7160 ValID CalleeID;
7161 SmallVector<ParamInfo, 16> ArgList;
7162 SmallVector<OperandBundleDef, 2> BundleList;
7163 LocTy CallLoc = Lex.getLoc();
7164
7165 if (TCK != CallInst::TCK_None &&
7166 parseToken(lltok::kw_call,
7167 "expected 'tail call', 'musttail call', or 'notail call'"))
7168 return true;
7169
7170 FastMathFlags FMF = EatFastMathFlagsIfPresent();
7171
7172 if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
7173 parseOptionalProgramAddrSpace(CallAddrSpace) ||
7174 parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
7175 parseValID(CalleeID) ||
7176 parseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
7177 PFS.getFunction().isVarArg()) ||
7178 parseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, BuiltinLoc) ||
7179 parseOptionalOperandBundles(BundleList, PFS))
7180 return true;
7181
7182 // If RetType is a non-function pointer type, then this is the short syntax
7183 // for the call, which means that RetType is just the return type. Infer the
7184 // rest of the function argument types from the arguments that are present.
7185 FunctionType *Ty = dyn_cast<FunctionType>(RetType);
7186 if (!Ty) {
7187 // Pull out the types of all of the arguments...
7188 std::vector<Type*> ParamTypes;
7189 for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
7190 ParamTypes.push_back(ArgList[i].V->getType());
7191
7192 if (!FunctionType::isValidReturnType(RetType))
7193 return error(RetTypeLoc, "Invalid result type for LLVM function");
7194
7195 Ty = FunctionType::get(RetType, ParamTypes, false);
7196 }
7197
7198 CalleeID.FTy = Ty;
7199
7200 // Look up the callee.
7201 Value *Callee;
7202 if (convertValIDToValue(PointerType::get(Ty, CallAddrSpace), CalleeID, Callee,
7203 &PFS, /*IsCall=*/true))
7204 return true;
7205
7206 // Set up the Attribute for the function.
7207 SmallVector<AttributeSet, 8> Attrs;
7208
7209 SmallVector<Value*, 8> Args;
7210
7211 // Loop through FunctionType's arguments and ensure they are specified
7212 // correctly. Also, gather any parameter attributes.
7213 FunctionType::param_iterator I = Ty->param_begin();
7214 FunctionType::param_iterator E = Ty->param_end();
7215 for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
7216 Type *ExpectedTy = nullptr;
7217 if (I != E) {
7218 ExpectedTy = *I++;
7219 } else if (!Ty->isVarArg()) {
7220 return error(ArgList[i].Loc, "too many arguments specified");
7221 }
7222
7223 if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
7224 return error(ArgList[i].Loc, "argument is not of expected type '" +
7225 getTypeString(ExpectedTy) + "'");
7226 Args.push_back(ArgList[i].V);
7227 Attrs.push_back(ArgList[i].Attrs);
7228 }
7229
7230 if (I != E)
7231 return error(CallLoc, "not enough parameters specified for call");
7232
7233 if (FnAttrs.hasAlignmentAttr())
7234 return error(CallLoc, "call instructions may not have an alignment");
7235
7236 // Finish off the Attribute and check them
7237 AttributeList PAL =
7238 AttributeList::get(Context, AttributeSet::get(Context, FnAttrs),
7239 AttributeSet::get(Context, RetAttrs), Attrs);
7240
7241 CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList);
7242 CI->setTailCallKind(TCK);
7243 CI->setCallingConv(CC);
7244 if (FMF.any()) {
7245 if (!isa<FPMathOperator>(CI)) {
7246 CI->deleteValue();
7247 return error(CallLoc, "fast-math-flags specified for call without "
7248 "floating-point scalar or vector return type");
7249 }
7250 CI->setFastMathFlags(FMF);
7251 }
7252 CI->setAttributes(PAL);
7253 ForwardRefAttrGroups[CI] = FwdRefAttrGrps;
7254 Inst = CI;
7255 return false;
7256}
7257
7258//===----------------------------------------------------------------------===//
7259// Memory Instructions.
7260//===----------------------------------------------------------------------===//
7261
7262/// parseAlloc
7263/// ::= 'alloca' 'inalloca'? 'swifterror'? Type (',' TypeAndValue)?
7264/// (',' 'align' i32)? (',', 'addrspace(n))?
7265int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
7266 Value *Size = nullptr;
7267 LocTy SizeLoc, TyLoc, ASLoc;
7268 MaybeAlign Alignment;
7269 unsigned AddrSpace = 0;
7270 Type *Ty = nullptr;
7271
7272 bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
7273 bool IsSwiftError = EatIfPresent(lltok::kw_swifterror);
7274
7275 if (parseType(Ty, TyLoc))
7276 return true;
7277
7278 if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
7279 return error(TyLoc, "invalid type for alloca");
7280
7281 bool AteExtraComma = false;
7282 if (EatIfPresent(lltok::comma)) {
7283 if (Lex.getKind() == lltok::kw_align) {
7284 if (parseOptionalAlignment(Alignment))
7285 return true;
7286 if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
7287 return true;
7288 } else if (Lex.getKind() == lltok::kw_addrspace) {
7289 ASLoc = Lex.getLoc();
7290 if (parseOptionalAddrSpace(AddrSpace))
7291 return true;
7292 } else if (Lex.getKind() == lltok::MetadataVar) {
7293 AteExtraComma = true;
7294 } else {
7295 if (parseTypeAndValue(Size, SizeLoc, PFS))
7296 return true;
7297 if (EatIfPresent(lltok::comma)) {
7298 if (Lex.getKind() == lltok::kw_align) {
7299 if (parseOptionalAlignment(Alignment))
7300 return true;
7301 if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
7302 return true;
7303 } else if (Lex.getKind() == lltok::kw_addrspace) {
7304 ASLoc = Lex.getLoc();
7305 if (parseOptionalAddrSpace(AddrSpace))
7306 return true;
7307 } else if (Lex.getKind() == lltok::MetadataVar) {
7308 AteExtraComma = true;
7309 }
7310 }
7311 }
7312 }
7313
7314 if (Size && !Size->getType()->isIntegerTy())
7315 return error(SizeLoc, "element count must have integer type");
7316
7317 SmallPtrSet<Type *, 4> Visited;
7318 if (!Alignment && !Ty->isSized(&Visited))
7319 return error(TyLoc, "Cannot allocate unsized type");
7320 if (!Alignment)
7321 Alignment = M->getDataLayout().getPrefTypeAlign(Ty);
7322 AllocaInst *AI = new AllocaInst(Ty, AddrSpace, Size, *Alignment);
7323 AI->setUsedWithInAlloca(IsInAlloca);
7324 AI->setSwiftError(IsSwiftError);
7325 Inst = AI;
7326 return AteExtraComma ? InstExtraComma : InstNormal;
7327}
7328
7329/// parseLoad
7330/// ::= 'load' 'volatile'? TypeAndValue (',' 'align' i32)?
7331/// ::= 'load' 'atomic' 'volatile'? TypeAndValue
7332/// 'singlethread'? AtomicOrdering (',' 'align' i32)?
7333int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
7334 Value *Val; LocTy Loc;
7335 MaybeAlign Alignment;
7336 bool AteExtraComma = false;
7337 bool isAtomic = false;
7338 AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
7339 SyncScope::ID SSID = SyncScope::System;
7340
7341 if (Lex.getKind() == lltok::kw_atomic) {
7342 isAtomic = true;
7343 Lex.Lex();
7344 }
7345
7346 bool isVolatile = false;
7347 if (Lex.getKind() == lltok::kw_volatile) {
7348 isVolatile = true;
7349 Lex.Lex();
7350 }
7351
7352 Type *Ty;
7353 LocTy ExplicitTypeLoc = Lex.getLoc();
7354 if (parseType(Ty) ||
7355 parseToken(lltok::comma, "expected comma after load's type") ||
7356 parseTypeAndValue(Val, Loc, PFS) ||
7357 parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
7358 parseOptionalCommaAlign(Alignment, AteExtraComma))
7359 return true;
7360
7361 if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
7362 return error(Loc, "load operand must be a pointer to a first class type");
7363 if (isAtomic && !Alignment)
7364 return error(Loc, "atomic load must have explicit non-zero alignment");
7365 if (Ordering == AtomicOrdering::Release ||
7366 Ordering == AtomicOrdering::AcquireRelease)
7367 return error(Loc, "atomic load cannot use Release ordering");
7368
7369 if (Ty != cast<PointerType>(Val->getType())->getElementType())
7370 return error(ExplicitTypeLoc,
7371 "explicit pointee type doesn't match operand's pointee type");
7372 SmallPtrSet<Type *, 4> Visited;
7373 if (!Alignment && !Ty->isSized(&Visited))
7374 return error(ExplicitTypeLoc, "loading unsized types is not allowed");
7375 if (!Alignment)
7376 Alignment = M->getDataLayout().getABITypeAlign(Ty);
7377 Inst = new LoadInst(Ty, Val, "", isVolatile, *Alignment, Ordering, SSID);
7378 return AteExtraComma ? InstExtraComma : InstNormal;
7379}
7380
7381/// parseStore
7382
7383/// ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
7384/// ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
7385/// 'singlethread'? AtomicOrdering (',' 'align' i32)?
7386int LLParser::parseStore(Instruction *&Inst, PerFunctionState &PFS) {
7387 Value *Val, *Ptr; LocTy Loc, PtrLoc;
7388 MaybeAlign Alignment;
7389 bool AteExtraComma = false;
7390 bool isAtomic = false;
7391 AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
7392 SyncScope::ID SSID = SyncScope::System;
7393
7394 if (Lex.getKind() == lltok::kw_atomic) {
7395 isAtomic = true;
7396 Lex.Lex();
7397 }
7398
7399 bool isVolatile = false;
7400 if (Lex.getKind() == lltok::kw_volatile) {
7401 isVolatile = true;
7402 Lex.Lex();
7403 }
7404
7405 if (parseTypeAndValue(Val, Loc, PFS) ||
7406 parseToken(lltok::comma, "expected ',' after store operand") ||
7407 parseTypeAndValue(Ptr, PtrLoc, PFS) ||
7408 parseScopeAndOrdering(isAtomic, SSID, Ordering) ||
7409 parseOptionalCommaAlign(Alignment, AteExtraComma))
7410 return true;
7411
7412 if (!Ptr->getType()->isPointerTy())
7413 return error(PtrLoc, "store operand must be a pointer");
7414 if (!Val->getType()->isFirstClassType())
7415 return error(Loc, "store operand must be a first class value");
7416 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
7417 return error(Loc, "stored value and pointer type do not match");
7418 if (isAtomic && !Alignment)
7419 return error(Loc, "atomic store must have explicit non-zero alignment");
7420 if (Ordering == AtomicOrdering::Acquire ||
7421 Ordering == AtomicOrdering::AcquireRelease)
7422 return error(Loc, "atomic store cannot use Acquire ordering");
7423 SmallPtrSet<Type *, 4> Visited;
7424 if (!Alignment && !Val->getType()->isSized(&Visited))
7425 return error(Loc, "storing unsized types is not allowed");
7426 if (!Alignment)
7427 Alignment = M->getDataLayout().getABITypeAlign(Val->getType());
7428
7429 Inst = new StoreInst(Val, Ptr, isVolatile, *Alignment, Ordering, SSID);
7430 return AteExtraComma ? InstExtraComma : InstNormal;
7431}
7432
7433/// parseCmpXchg
7434/// ::= 'cmpxchg' 'weak'? 'volatile'? TypeAndValue ',' TypeAndValue ','
7435/// TypeAndValue 'singlethread'? AtomicOrdering AtomicOrdering
7436int LLParser::parseCmpXchg(Instruction *&Inst, PerFunctionState &PFS) {
7437 Value *Ptr, *Cmp, *New; LocTy PtrLoc, CmpLoc, NewLoc;
7438 bool AteExtraComma = false;
7439 AtomicOrdering SuccessOrdering = AtomicOrdering::NotAtomic;
7440 AtomicOrdering FailureOrdering = AtomicOrdering::NotAtomic;
7441 SyncScope::ID SSID = SyncScope::System;
7442 bool isVolatile = false;
7443 bool isWeak = false;
7444
7445 if (EatIfPresent(lltok::kw_weak))
7446 isWeak = true;
7447
7448 if (EatIfPresent(lltok::kw_volatile))
7449 isVolatile = true;
7450
7451 if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
7452 parseToken(lltok::comma, "expected ',' after cmpxchg address") ||
7453 parseTypeAndValue(Cmp, CmpLoc, PFS) ||
7454 parseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") ||
7455 parseTypeAndValue(New, NewLoc, PFS) ||
7456 parseScopeAndOrdering(true /*Always atomic*/, SSID, SuccessOrdering) ||
7457 parseOrdering(FailureOrdering))
7458 return true;
7459
7460 if (SuccessOrdering == AtomicOrdering::Unordered ||
7461 FailureOrdering == AtomicOrdering::Unordered)
7462 return tokError("cmpxchg cannot be unordered");
7463 if (isStrongerThan(FailureOrdering, SuccessOrdering))
7464 return tokError("cmpxchg failure argument shall be no stronger than the "
7465 "success argument");
7466 if (FailureOrdering == AtomicOrdering::Release ||
7467 FailureOrdering == AtomicOrdering::AcquireRelease)
7468 return tokError(
7469 "cmpxchg failure ordering cannot include release semantics");
7470 if (!Ptr->getType()->isPointerTy())
7471 return error(PtrLoc, "cmpxchg operand must be a pointer");
7472 if (cast<PointerType>(Ptr->getType())->getElementType() != Cmp->getType())
7473 return error(CmpLoc, "compare value and pointer type do not match");
7474 if (cast<PointerType>(Ptr->getType())->getElementType() != New->getType())
7475 return error(NewLoc, "new value and pointer type do not match");
7476 if (!New->getType()->isFirstClassType())
7477 return error(NewLoc, "cmpxchg operand must be a first class value");
7478
7479 Align Alignment(
7480 PFS.getFunction().getParent()->getDataLayout().getTypeStoreSize(
7481 Cmp->getType()));
7482
7483 AtomicCmpXchgInst *CXI = new AtomicCmpXchgInst(
7484 Ptr, Cmp, New, Alignment, SuccessOrdering, FailureOrdering, SSID);
7485 CXI->setVolatile(isVolatile);
7486 CXI->setWeak(isWeak);
7487 Inst = CXI;
7488 return AteExtraComma ? InstExtraComma : InstNormal;
7489}
7490
7491/// parseAtomicRMW
7492/// ::= 'atomicrmw' 'volatile'? BinOp TypeAndValue ',' TypeAndValue
7493/// 'singlethread'? AtomicOrdering
7494int LLParser::parseAtomicRMW(Instruction *&Inst, PerFunctionState &PFS) {
7495 Value *Ptr, *Val; LocTy PtrLoc, ValLoc;
7496 bool AteExtraComma = false;
7497 AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
7498 SyncScope::ID SSID = SyncScope::System;
7499 bool isVolatile = false;
7500 bool IsFP = false;
7501 AtomicRMWInst::BinOp Operation;
7502
7503 if (EatIfPresent(lltok::kw_volatile))
7504 isVolatile = true;
7505
7506 switch (Lex.getKind()) {
7507 default:
7508 return tokError("expected binary operation in atomicrmw");
7509 case lltok::kw_xchg: Operation = AtomicRMWInst::Xchg; break;
7510 case lltok::kw_add: Operation = AtomicRMWInst::Add; break;
7511 case lltok::kw_sub: Operation = AtomicRMWInst::Sub; break;
7512 case lltok::kw_and: Operation = AtomicRMWInst::And; break;
7513 case lltok::kw_nand: Operation = AtomicRMWInst::Nand; break;
7514 case lltok::kw_or: Operation = AtomicRMWInst::Or; break;
7515 case lltok::kw_xor: Operation = AtomicRMWInst::Xor; break;
7516 case lltok::kw_max: Operation = AtomicRMWInst::Max; break;
7517 case lltok::kw_min: Operation = AtomicRMWInst::Min; break;
7518 case lltok::kw_umax: Operation = AtomicRMWInst::UMax; break;
7519 case lltok::kw_umin: Operation = AtomicRMWInst::UMin; break;
7520 case lltok::kw_fadd:
7521 Operation = AtomicRMWInst::FAdd;
7522 IsFP = true;
7523 break;
7524 case lltok::kw_fsub:
7525 Operation = AtomicRMWInst::FSub;
7526 IsFP = true;
7527 break;
7528 }
7529 Lex.Lex(); // Eat the operation.
7530
7531 if (parseTypeAndValue(Ptr, PtrLoc, PFS) ||
7532 parseToken(lltok::comma, "expected ',' after atomicrmw address") ||
7533 parseTypeAndValue(Val, ValLoc, PFS) ||
7534 parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering))
7535 return true;
7536
7537 if (Ordering == AtomicOrdering::Unordered)
7538 return tokError("atomicrmw cannot be unordered");
7539 if (!Ptr->getType()->isPointerTy())
7540 return error(PtrLoc, "atomicrmw operand must be a pointer");
7541 if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
7542 return error(ValLoc, "atomicrmw value and pointer type do not match");
7543
7544 if (Operation == AtomicRMWInst::Xchg) {
7545 if (!Val->getType()->isIntegerTy() &&
7546 !Val->getType()->isFloatingPointTy()) {
7547 return error(ValLoc,
7548 "atomicrmw " + AtomicRMWInst::getOperationName(Operation) +
7549 " operand must be an integer or floating point type");
7550 }
7551 } else if (IsFP) {
7552 if (!Val->getType()->isFloatingPointTy()) {
7553 return error(ValLoc, "atomicrmw " +
7554 AtomicRMWInst::getOperationName(Operation) +
7555 " operand must be a floating point type");
7556 }
7557 } else {
7558 if (!Val->getType()->isIntegerTy()) {
7559 return error(ValLoc, "atomicrmw " +
7560 AtomicRMWInst::getOperationName(Operation) +
7561 " operand must be an integer");
7562 }
7563 }
7564
7565 unsigned Size = Val->getType()->getPrimitiveSizeInBits();
7566 if (Size < 8 || (Size & (Size - 1)))
7567 return error(ValLoc, "atomicrmw operand must be power-of-two byte-sized"
7568 " integer");
7569 Align Alignment(
7570 PFS.getFunction().getParent()->getDataLayout().getTypeStoreSize(
7571 Val->getType()));
7572 AtomicRMWInst *RMWI =
7573 new AtomicRMWInst(Operation, Ptr, Val, Alignment, Ordering, SSID);
7574 RMWI->setVolatile(isVolatile);
7575 Inst = RMWI;
7576 return AteExtraComma ? InstExtraComma : InstNormal;
7577}
7578
7579/// parseFence
7580/// ::= 'fence' 'singlethread'? AtomicOrdering
7581int LLParser::parseFence(Instruction *&Inst, PerFunctionState &PFS) {
7582 AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
7583 SyncScope::ID SSID = SyncScope::System;
7584 if (parseScopeAndOrdering(true /*Always atomic*/, SSID, Ordering))
7585 return true;
7586
7587 if (Ordering == AtomicOrdering::Unordered)
7588 return tokError("fence cannot be unordered");
7589 if (Ordering == AtomicOrdering::Monotonic)
7590 return tokError("fence cannot be monotonic");
7591
7592 Inst = new FenceInst(Context, Ordering, SSID);
7593 return InstNormal;
7594}
7595
7596/// parseGetElementPtr
7597/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
7598int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
7599 Value *Ptr = nullptr;
7600 Value *Val = nullptr;
7601 LocTy Loc, EltLoc;
7602
7603 bool InBounds = EatIfPresent(lltok::kw_inbounds);
7604
7605 Type *Ty = nullptr;
7606 LocTy ExplicitTypeLoc = Lex.getLoc();
7607 if (parseType(Ty) ||
7608 parseToken(lltok::comma, "expected comma after getelementptr's type") ||
7609 parseTypeAndValue(Ptr, Loc, PFS))
7610 return true;
7611
7612 Type *BaseType = Ptr->getType();
7613 PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
7614 if (!BasePointerType)
7615 return error(Loc, "base of getelementptr must be a pointer");
7616
7617 if (Ty != BasePointerType->getElementType())
7618 return error(ExplicitTypeLoc,
7619 "explicit pointee type doesn't match operand's pointee type");
7620
7621 SmallVector<Value*, 16> Indices;
7622 bool AteExtraComma = false;
7623 // GEP returns a vector of pointers if at least one of parameters is a vector.
7624 // All vector parameters should have the same vector width.
7625 ElementCount GEPWidth = BaseType->isVectorTy()
7626 ? cast<VectorType>(BaseType)->getElementCount()
7627 : ElementCount::getFixed(0);
7628
7629 while (EatIfPresent(lltok::comma)) {
7630 if (Lex.getKind() == lltok::MetadataVar) {
7631 AteExtraComma = true;
7632 break;
7633 }
7634 if (parseTypeAndValue(Val, EltLoc, PFS))
7635 return true;
7636 if (!Val->getType()->isIntOrIntVectorTy())
7637 return error(EltLoc, "getelementptr index must be an integer");
7638
7639 if (auto *ValVTy = dyn_cast<VectorType>(Val->getType())) {
7640 ElementCount ValNumEl = ValVTy->getElementCount();
7641 if (GEPWidth != ElementCount::getFixed(0) && GEPWidth != ValNumEl)
7642 return error(
7643 EltLoc,
7644 "getelementptr vector index has a wrong number of elements");
7645 GEPWidth = ValNumEl;
7646 }
7647 Indices.push_back(Val);
7648 }
7649
7650 SmallPtrSet<Type*, 4> Visited;
7651 if (!Indices.empty() && !Ty->isSized(&Visited))
7652 return error(Loc, "base element of getelementptr must be sized");
7653
7654 if (!GetElementPtrInst::getIndexedType(Ty, Indices))
7655 return error(Loc, "invalid getelementptr indices");
7656 Inst = GetElementPtrInst::Create(Ty, Ptr, Indices);
7657 if (InBounds)
7658 cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
7659 return AteExtraComma ? InstExtraComma : InstNormal;
7660}
7661
7662/// parseExtractValue
7663/// ::= 'extractvalue' TypeAndValue (',' uint32)+
7664int LLParser::parseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
7665 Value *Val; LocTy Loc;
7666 SmallVector<unsigned, 4> Indices;
7667 bool AteExtraComma;
7668 if (parseTypeAndValue(Val, Loc, PFS) ||
7669 parseIndexList(Indices, AteExtraComma))
7670 return true;
7671
7672 if (!Val->getType()->isAggregateType())
7673 return error(Loc, "extractvalue operand must be aggregate type");
7674
7675 if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
7676 return error(Loc, "invalid indices for extractvalue");
7677 Inst = ExtractValueInst::Create(Val, Indices);
7678 return AteExtraComma ? InstExtraComma : InstNormal;
7679}
7680
7681/// parseInsertValue
7682/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
7683int LLParser::parseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
7684 Value *Val0, *Val1; LocTy Loc0, Loc1;
7685 SmallVector<unsigned, 4> Indices;
7686 bool AteExtraComma;
7687 if (parseTypeAndValue(Val0, Loc0, PFS) ||
7688 parseToken(lltok::comma, "expected comma after insertvalue operand") ||
7689 parseTypeAndValue(Val1, Loc1, PFS) ||
7690 parseIndexList(Indices, AteExtraComma))
7691 return true;
7692
7693 if (!Val0->getType()->isAggregateType())
7694 return error(Loc0, "insertvalue operand must be aggregate type");
7695
7696 Type *IndexedType = ExtractValueInst::getIndexedType(Val0->getType(), Indices);
7697 if (!IndexedType)
7698 return error(Loc0, "invalid indices for insertvalue");
7699 if (IndexedType != Val1->getType())
7700 return error(Loc1, "insertvalue operand and field disagree in type: '" +
7701 getTypeString(Val1->getType()) + "' instead of '" +
7702 getTypeString(IndexedType) + "'");
7703 Inst = InsertValueInst::Create(Val0, Val1, Indices);
7704 return AteExtraComma ? InstExtraComma : InstNormal;
7705}
7706
7707//===----------------------------------------------------------------------===//
7708// Embedded metadata.
7709//===----------------------------------------------------------------------===//
7710
7711/// parseMDNodeVector
7712/// ::= { Element (',' Element)* }
7713/// Element
7714/// ::= 'null' | TypeAndValue
7715bool LLParser::parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts) {
7716 if (parseToken(lltok::lbrace, "expected '{' here"))
7717 return true;
7718
7719 // Check for an empty list.
7720 if (EatIfPresent(lltok::rbrace))
7721 return false;
7722
7723 do {
7724 // Null is a special case since it is typeless.
7725 if (EatIfPresent(lltok::kw_null)) {
7726 Elts.push_back(nullptr);
7727 continue;
7728 }
7729
7730 Metadata *MD;
7731 if (parseMetadata(MD, nullptr))
7732 return true;
7733 Elts.push_back(MD);
7734 } while (EatIfPresent(lltok::comma));
7735
7736 return parseToken(lltok::rbrace, "expected end of metadata node");
7737}
7738
7739//===----------------------------------------------------------------------===//
7740// Use-list order directives.
7741//===----------------------------------------------------------------------===//
7742bool LLParser::sortUseListOrder(Value *V, ArrayRef<unsigned> Indexes,
7743 SMLoc Loc) {
7744 if (V->use_empty())
7745 return error(Loc, "value has no uses");
7746
7747 unsigned NumUses = 0;
7748 SmallDenseMap<const Use *, unsigned, 16> Order;
7749 for (const Use &U : V->uses()) {
7750 if (++NumUses > Indexes.size())
7751 break;
7752 Order[&U] = Indexes[NumUses - 1];
7753 }
7754 if (NumUses < 2)
7755 return error(Loc, "value only has one use");
7756 if (Order.size() != Indexes.size() || NumUses > Indexes.size())
7757 return error(Loc,
7758 "wrong number of indexes, expected " + Twine(V->getNumUses()));
7759
7760 V->sortUseList([&](const Use &L, const Use &R) {
7761 return Order.lookup(&L) < Order.lookup(&R);
7762 });
7763 return false;
7764}
7765
7766/// parseUseListOrderIndexes
7767/// ::= '{' uint32 (',' uint32)+ '}'
7768bool LLParser::parseUseListOrderIndexes(SmallVectorImpl<unsigned> &Indexes) {
7769 SMLoc Loc = Lex.getLoc();
7770 if (parseToken(lltok::lbrace, "expected '{' here"))
7771 return true;
7772 if (Lex.getKind() == lltok::rbrace)
7773 return Lex.Error("expected non-empty list of uselistorder indexes");
7774
7775 // Use Offset, Max, and IsOrdered to check consistency of indexes. The
7776 // indexes should be distinct numbers in the range [0, size-1], and should
7777 // not be in order.
7778 unsigned Offset = 0;
7779 unsigned Max = 0;
7780 bool IsOrdered = true;
7781 assert(Indexes.empty() && "Expected empty order vector");
7782 do {
7783 unsigned Index;
7784 if (parseUInt32(Index))
7785 return true;
7786
7787 // Update consistency checks.
7788 Offset += Index - Indexes.size();
7789 Max = std::max(Max, Index);
7790 IsOrdered &= Index == Indexes.size();
7791
7792 Indexes.push_back(Index);
7793 } while (EatIfPresent(lltok::comma));
7794
7795 if (parseToken(lltok::rbrace, "expected '}' here"))
7796 return true;
7797
7798 if (Indexes.size() < 2)
7799 return error(Loc, "expected >= 2 uselistorder indexes");
7800 if (Offset != 0 || Max >= Indexes.size())
7801 return error(Loc,
7802 "expected distinct uselistorder indexes in range [0, size)");
7803 if (IsOrdered)
7804 return error(Loc, "expected uselistorder indexes to change the order");
7805
7806 return false;
7807}
7808
7809/// parseUseListOrder
7810/// ::= 'uselistorder' Type Value ',' UseListOrderIndexes
7811bool LLParser::parseUseListOrder(PerFunctionState *PFS) {
7812 SMLoc Loc = Lex.getLoc();
7813 if (parseToken(lltok::kw_uselistorder, "expected uselistorder directive"))
7814 return true;
7815
7816 Value *V;
7817 SmallVector<unsigned, 16> Indexes;
7818 if (parseTypeAndValue(V, PFS) ||
7819 parseToken(lltok::comma, "expected comma in uselistorder directive") ||
7820 parseUseListOrderIndexes(Indexes))
7821 return true;
7822
7823 return sortUseListOrder(V, Indexes, Loc);
7824}
7825
7826/// parseUseListOrderBB
7827/// ::= 'uselistorder_bb' @foo ',' %bar ',' UseListOrderIndexes
7828bool LLParser::parseUseListOrderBB() {
7829 assert(Lex.getKind() == lltok::kw_uselistorder_bb);
7830 SMLoc Loc = Lex.getLoc();
7831 Lex.Lex();
7832
7833 ValID Fn, Label;
7834 SmallVector<unsigned, 16> Indexes;
7835 if (parseValID(Fn) ||
7836 parseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
7837 parseValID(Label) ||
7838 parseToken(lltok::comma, "expected comma in uselistorder_bb directive") ||
7839 parseUseListOrderIndexes(Indexes))
7840 return true;
7841
7842 // Check the function.
7843 GlobalValue *GV;
7844 if (Fn.Kind == ValID::t_GlobalName)
7845 GV = M->getNamedValue(Fn.StrVal);
7846 else if (Fn.Kind == ValID::t_GlobalID)
7847 GV = Fn.UIntVal < NumberedVals.size() ? NumberedVals[Fn.UIntVal] : nullptr;
7848 else
7849 return error(Fn.Loc, "expected function name in uselistorder_bb");
7850 if (!GV)
7851 return error(Fn.Loc,
7852 "invalid function forward reference in uselistorder_bb");
7853 auto *F = dyn_cast<Function>(GV);
7854 if (!F)
7855 return error(Fn.Loc, "expected function name in uselistorder_bb");
7856 if (F->isDeclaration())
7857 return error(Fn.Loc, "invalid declaration in uselistorder_bb");
7858
7859 // Check the basic block.
7860 if (Label.Kind == ValID::t_LocalID)
7861 return error(Label.Loc, "invalid numeric label in uselistorder_bb");
7862 if (Label.Kind != ValID::t_LocalName)
7863 return error(Label.Loc, "expected basic block name in uselistorder_bb");
7864 Value *V = F->getValueSymbolTable()->lookup(Label.StrVal);
7865 if (!V)
7866 return error(Label.Loc, "invalid basic block in uselistorder_bb");
7867 if (!isa<BasicBlock>(V))
7868 return error(Label.Loc, "expected basic block in uselistorder_bb");
7869
7870 return sortUseListOrder(V, Indexes, Loc);
7871}
7872
7873/// ModuleEntry
7874/// ::= 'module' ':' '(' 'path' ':' STRINGCONSTANT ',' 'hash' ':' Hash ')'
7875/// Hash ::= '(' UInt32 ',' UInt32 ',' UInt32 ',' UInt32 ',' UInt32 ')'
7876bool LLParser::parseModuleEntry(unsigned ID) {
7877 assert(Lex.getKind() == lltok::kw_module);
7878 Lex.Lex();
7879
7880 std::string Path;
7881 if (parseToken(lltok::colon, "expected ':' here") ||
7882 parseToken(lltok::lparen, "expected '(' here") ||
7883 parseToken(lltok::kw_path, "expected 'path' here") ||
7884 parseToken(lltok::colon, "expected ':' here") ||
7885 parseStringConstant(Path) ||
7886 parseToken(lltok::comma, "expected ',' here") ||
7887 parseToken(lltok::kw_hash, "expected 'hash' here") ||
7888 parseToken(lltok::colon, "expected ':' here") ||
7889 parseToken(lltok::lparen, "expected '(' here"))
7890 return true;
7891
7892 ModuleHash Hash;
7893 if (parseUInt32(Hash[0]) || parseToken(lltok::comma, "expected ',' here") ||
7894 parseUInt32(Hash[1]) || parseToken(lltok::comma, "expected ',' here") ||
7895 parseUInt32(Hash[2]) || parseToken(lltok::comma, "expected ',' here") ||
7896 parseUInt32(Hash[3]) || parseToken(lltok::comma, "expected ',' here") ||
7897 parseUInt32(Hash[4]))
7898 return true;
7899
7900 if (parseToken(lltok::rparen, "expected ')' here") ||
7901 parseToken(lltok::rparen, "expected ')' here"))
7902 return true;
7903
7904 auto ModuleEntry = Index->addModule(Path, ID, Hash);
7905 ModuleIdMap[ID] = ModuleEntry->first();
7906
7907 return false;
7908}
7909
7910/// TypeIdEntry
7911/// ::= 'typeid' ':' '(' 'name' ':' STRINGCONSTANT ',' TypeIdSummary ')'
7912bool LLParser::parseTypeIdEntry(unsigned ID) {
7913 assert(Lex.getKind() == lltok::kw_typeid);
7914 Lex.Lex();
7915
7916 std::string Name;
7917 if (parseToken(lltok::colon, "expected ':' here") ||
7918 parseToken(lltok::lparen, "expected '(' here") ||
7919 parseToken(lltok::kw_name, "expected 'name' here") ||
7920 parseToken(lltok::colon, "expected ':' here") ||
7921 parseStringConstant(Name))
7922 return true;
7923
7924 TypeIdSummary &TIS = Index->getOrInsertTypeIdSummary(Name);
7925 if (parseToken(lltok::comma, "expected ',' here") ||
7926 parseTypeIdSummary(TIS) || parseToken(lltok::rparen, "expected ')' here"))
7927 return true;
7928
7929 // Check if this ID was forward referenced, and if so, update the
7930 // corresponding GUIDs.
7931 auto FwdRefTIDs = ForwardRefTypeIds.find(ID);
7932 if (FwdRefTIDs != ForwardRefTypeIds.end()) {
7933 for (auto TIDRef : FwdRefTIDs->second) {
7934 assert(!*TIDRef.first &&
7935 "Forward referenced type id GUID expected to be 0");
7936 *TIDRef.first = GlobalValue::getGUID(Name);
7937 }
7938 ForwardRefTypeIds.erase(FwdRefTIDs);
7939 }
7940
7941 return false;
7942}
7943
7944/// TypeIdSummary
7945/// ::= 'summary' ':' '(' TypeTestResolution [',' OptionalWpdResolutions]? ')'
7946bool LLParser::parseTypeIdSummary(TypeIdSummary &TIS) {
7947 if (parseToken(lltok::kw_summary, "expected 'summary' here") ||
7948 parseToken(lltok::colon, "expected ':' here") ||
7949 parseToken(lltok::lparen, "expected '(' here") ||
7950 parseTypeTestResolution(TIS.TTRes))
7951 return true;
7952
7953 if (EatIfPresent(lltok::comma)) {
7954 // Expect optional wpdResolutions field
7955 if (parseOptionalWpdResolutions(TIS.WPDRes))
7956 return true;
7957 }
7958
7959 if (parseToken(lltok::rparen, "expected ')' here"))
7960 return true;
7961
7962 return false;
7963}
7964
7965static ValueInfo EmptyVI =
7966 ValueInfo(false, (GlobalValueSummaryMapTy::value_type *)-8);
7967
7968/// TypeIdCompatibleVtableEntry
7969/// ::= 'typeidCompatibleVTable' ':' '(' 'name' ':' STRINGCONSTANT ','
7970/// TypeIdCompatibleVtableInfo
7971/// ')'
7972bool LLParser::parseTypeIdCompatibleVtableEntry(unsigned ID) {
7973 assert(Lex.getKind() == lltok::kw_typeidCompatibleVTable);
7974 Lex.Lex();
7975
7976 std::string Name;
7977 if (parseToken(lltok::colon, "expected ':' here") ||
7978 parseToken(lltok::lparen, "expected '(' here") ||
7979 parseToken(lltok::kw_name, "expected 'name' here") ||
7980 parseToken(lltok::colon, "expected ':' here") ||
7981 parseStringConstant(Name))
7982 return true;
7983
7984 TypeIdCompatibleVtableInfo &TI =
7985 Index->getOrInsertTypeIdCompatibleVtableSummary(Name);
7986 if (parseToken(lltok::comma, "expected ',' here") ||
7987 parseToken(lltok::kw_summary, "expected 'summary' here") ||
7988 parseToken(lltok::colon, "expected ':' here") ||
7989 parseToken(lltok::lparen, "expected '(' here"))
7990 return true;
7991
7992 IdToIndexMapType IdToIndexMap;
7993 // parse each call edge
7994 do {
7995 uint64_t Offset;
7996 if (parseToken(lltok::lparen, "expected '(' here") ||
7997 parseToken(lltok::kw_offset, "expected 'offset' here") ||
7998 parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) ||
7999 parseToken(lltok::comma, "expected ',' here"))
8000 return true;
8001
8002 LocTy Loc = Lex.getLoc();
8003 unsigned GVId;
8004 ValueInfo VI;
8005 if (parseGVReference(VI, GVId))
8006 return true;
8007
8008 // Keep track of the TypeIdCompatibleVtableInfo array index needing a
8009 // forward reference. We will save the location of the ValueInfo needing an
8010 // update, but can only do so once the std::vector is finalized.
8011 if (VI == EmptyVI)
8012 IdToIndexMap[GVId].push_back(std::make_pair(TI.size(), Loc));
8013 TI.push_back({Offset, VI});
8014
8015 if (parseToken(lltok::rparen, "expected ')' in call"))
8016 return true;
8017 } while (EatIfPresent(lltok::comma));
8018
8019 // Now that the TI vector is finalized, it is safe to save the locations
8020 // of any forward GV references that need updating later.
8021 for (auto I : IdToIndexMap) {
8022 auto &Infos = ForwardRefValueInfos[I.first];
8023 for (auto P : I.second) {
8024 assert(TI[P.first].VTableVI == EmptyVI &&
8025 "Forward referenced ValueInfo expected to be empty");
8026 Infos.emplace_back(&TI[P.first].VTableVI, P.second);
8027 }
8028 }
8029
8030 if (parseToken(lltok::rparen, "expected ')' here") ||
8031 parseToken(lltok::rparen, "expected ')' here"))
8032 return true;
8033
8034 // Check if this ID was forward referenced, and if so, update the
8035 // corresponding GUIDs.
8036 auto FwdRefTIDs = ForwardRefTypeIds.find(ID);
8037 if (FwdRefTIDs != ForwardRefTypeIds.end()) {
8038 for (auto TIDRef : FwdRefTIDs->second) {
8039 assert(!*TIDRef.first &&
8040 "Forward referenced type id GUID expected to be 0");
8041 *TIDRef.first = GlobalValue::getGUID(Name);
8042 }
8043 ForwardRefTypeIds.erase(FwdRefTIDs);
8044 }
8045
8046 return false;
8047}
8048
8049/// TypeTestResolution
8050/// ::= 'typeTestRes' ':' '(' 'kind' ':'
8051/// ( 'unsat' | 'byteArray' | 'inline' | 'single' | 'allOnes' ) ','
8052/// 'sizeM1BitWidth' ':' SizeM1BitWidth [',' 'alignLog2' ':' UInt64]?
8053/// [',' 'sizeM1' ':' UInt64]? [',' 'bitMask' ':' UInt8]?
8054/// [',' 'inlinesBits' ':' UInt64]? ')'
8055bool LLParser::parseTypeTestResolution(TypeTestResolution &TTRes) {
8056 if (parseToken(lltok::kw_typeTestRes, "expected 'typeTestRes' here") ||
8057 parseToken(lltok::colon, "expected ':' here") ||
8058 parseToken(lltok::lparen, "expected '(' here") ||
8059 parseToken(lltok::kw_kind, "expected 'kind' here") ||
8060 parseToken(lltok::colon, "expected ':' here"))
8061 return true;
8062
8063 switch (Lex.getKind()) {
8064 case lltok::kw_unknown:
8065 TTRes.TheKind = TypeTestResolution::Unknown;
8066 break;
8067 case lltok::kw_unsat:
8068 TTRes.TheKind = TypeTestResolution::Unsat;
8069 break;
8070 case lltok::kw_byteArray:
8071 TTRes.TheKind = TypeTestResolution::ByteArray;
8072 break;
8073 case lltok::kw_inline:
8074 TTRes.TheKind = TypeTestResolution::Inline;
8075 break;
8076 case lltok::kw_single:
8077 TTRes.TheKind = TypeTestResolution::Single;
8078 break;
8079 case lltok::kw_allOnes:
8080 TTRes.TheKind = TypeTestResolution::AllOnes;
8081 break;
8082 default:
8083 return error(Lex.getLoc(), "unexpected TypeTestResolution kind");
8084 }
8085 Lex.Lex();
8086
8087 if (parseToken(lltok::comma, "expected ',' here") ||
8088 parseToken(lltok::kw_sizeM1BitWidth, "expected 'sizeM1BitWidth' here") ||
8089 parseToken(lltok::colon, "expected ':' here") ||
8090 parseUInt32(TTRes.SizeM1BitWidth))
8091 return true;
8092
8093 // parse optional fields
8094 while (EatIfPresent(lltok::comma)) {
8095 switch (Lex.getKind()) {
8096 case lltok::kw_alignLog2:
8097 Lex.Lex();
8098 if (parseToken(lltok::colon, "expected ':'") ||
8099 parseUInt64(TTRes.AlignLog2))
8100 return true;
8101 break;
8102 case lltok::kw_sizeM1:
8103 Lex.Lex();
8104 if (parseToken(lltok::colon, "expected ':'") || parseUInt64(TTRes.SizeM1))
8105 return true;
8106 break;
8107 case lltok::kw_bitMask: {
8108 unsigned Val;
8109 Lex.Lex();
8110 if (parseToken(lltok::colon, "expected ':'") || parseUInt32(Val))
8111 return true;
8112 assert(Val <= 0xff);
8113 TTRes.BitMask = (uint8_t)Val;
8114 break;
8115 }
8116 case lltok::kw_inlineBits:
8117 Lex.Lex();
8118 if (parseToken(lltok::colon, "expected ':'") ||
8119 parseUInt64(TTRes.InlineBits))
8120 return true;
8121 break;
8122 default:
8123 return error(Lex.getLoc(), "expected optional TypeTestResolution field");
8124 }
8125 }
8126
8127 if (parseToken(lltok::rparen, "expected ')' here"))
8128 return true;
8129
8130 return false;
8131}
8132
8133/// OptionalWpdResolutions
8134/// ::= 'wpsResolutions' ':' '(' WpdResolution [',' WpdResolution]* ')'
8135/// WpdResolution ::= '(' 'offset' ':' UInt64 ',' WpdRes ')'
8136bool LLParser::parseOptionalWpdResolutions(
8137 std::map<uint64_t, WholeProgramDevirtResolution> &WPDResMap) {
8138 if (parseToken(lltok::kw_wpdResolutions, "expected 'wpdResolutions' here") ||
8139 parseToken(lltok::colon, "expected ':' here") ||
8140 parseToken(lltok::lparen, "expected '(' here"))
8141 return true;
8142
8143 do {
8144 uint64_t Offset;
8145 WholeProgramDevirtResolution WPDRes;
8146 if (parseToken(lltok::lparen, "expected '(' here") ||
8147 parseToken(lltok::kw_offset, "expected 'offset' here") ||
8148 parseToken(lltok::colon, "expected ':' here") || parseUInt64(Offset) ||
8149 parseToken(lltok::comma, "expected ',' here") || parseWpdRes(WPDRes) ||
8150 parseToken(lltok::rparen, "expected ')' here"))
8151 return true;
8152 WPDResMap[Offset] = WPDRes;
8153 } while (EatIfPresent(lltok::comma));
8154
8155 if (parseToken(lltok::rparen, "expected ')' here"))
8156 return true;
8157
8158 return false;
8159}
8160
8161/// WpdRes
8162/// ::= 'wpdRes' ':' '(' 'kind' ':' 'indir'
8163/// [',' OptionalResByArg]? ')'
8164/// ::= 'wpdRes' ':' '(' 'kind' ':' 'singleImpl'
8165/// ',' 'singleImplName' ':' STRINGCONSTANT ','
8166/// [',' OptionalResByArg]? ')'
8167/// ::= 'wpdRes' ':' '(' 'kind' ':' 'branchFunnel'
8168/// [',' OptionalResByArg]? ')'
8169bool LLParser::parseWpdRes(WholeProgramDevirtResolution &WPDRes) {
8170 if (parseToken(lltok::kw_wpdRes, "expected 'wpdRes' here") ||
8171 parseToken(lltok::colon, "expected ':' here") ||
8172 parseToken(lltok::lparen, "expected '(' here") ||
8173 parseToken(lltok::kw_kind, "expected 'kind' here") ||
8174 parseToken(lltok::colon, "expected ':' here"))
8175 return true;
8176
8177 switch (Lex.getKind()) {
8178 case lltok::kw_indir:
8179 WPDRes.TheKind = WholeProgramDevirtResolution::Indir;
8180 break;
8181 case lltok::kw_singleImpl:
8182 WPDRes.TheKind = WholeProgramDevirtResolution::SingleImpl;
8183 break;
8184 case lltok::kw_branchFunnel:
8185 WPDRes.TheKind = WholeProgramDevirtResolution::BranchFunnel;
8186 break;
8187 default:
8188 return error(Lex.getLoc(), "unexpected WholeProgramDevirtResolution kind");
8189 }
8190 Lex.Lex();
8191
8192 // parse optional fields
8193 while (EatIfPresent(lltok::comma)) {
8194 switch (Lex.getKind()) {
8195 case lltok::kw_singleImplName:
8196 Lex.Lex();
8197 if (parseToken(lltok::colon, "expected ':' here") ||
8198 parseStringConstant(WPDRes.SingleImplName))
8199 return true;
8200 break;
8201 case lltok::kw_resByArg:
8202 if (parseOptionalResByArg(WPDRes.ResByArg))
8203 return true;
8204 break;
8205 default:
8206 return error(Lex.getLoc(),
8207 "expected optional WholeProgramDevirtResolution field");
8208 }
8209 }
8210
8211 if (parseToken(lltok::rparen, "expected ')' here"))
8212 return true;
8213
8214 return false;
8215}
8216
8217/// OptionalResByArg
8218/// ::= 'wpdRes' ':' '(' ResByArg[, ResByArg]* ')'
8219/// ResByArg ::= Args ',' 'byArg' ':' '(' 'kind' ':'
8220/// ( 'indir' | 'uniformRetVal' | 'UniqueRetVal' |
8221/// 'virtualConstProp' )
8222/// [',' 'info' ':' UInt64]? [',' 'byte' ':' UInt32]?
8223/// [',' 'bit' ':' UInt32]? ')'
8224bool LLParser::parseOptionalResByArg(
8225 std::map<std::vector<uint64_t>, WholeProgramDevirtResolution::ByArg>
8226 &ResByArg) {
8227 if (parseToken(lltok::kw_resByArg, "expected 'resByArg' here") ||
8228 parseToken(lltok::colon, "expected ':' here") ||
8229 parseToken(lltok::lparen, "expected '(' here"))
8230 return true;
8231
8232 do {
8233 std::vector<uint64_t> Args;
8234 if (parseArgs(Args) || parseToken(lltok::comma, "expected ',' here") ||
8235 parseToken(lltok::kw_byArg, "expected 'byArg here") ||
8236 parseToken(lltok::colon, "expected ':' here") ||
8237 parseToken(lltok::lparen, "expected '(' here") ||
8238 parseToken(lltok::kw_kind, "expected 'kind' here") ||
8239 parseToken(lltok::colon, "expected ':' here"))
8240 return true;
8241
8242 WholeProgramDevirtResolution::ByArg ByArg;
8243 switch (Lex.getKind()) {
8244 case lltok::kw_indir:
8245 ByArg.TheKind = WholeProgramDevirtResolution::ByArg::Indir;
8246 break;
8247 case lltok::kw_uniformRetVal:
8248 ByArg.TheKind = WholeProgramDevirtResolution::ByArg::UniformRetVal;
8249 break;
8250 case lltok::kw_uniqueRetVal:
8251 ByArg.TheKind = WholeProgramDevirtResolution::ByArg::UniqueRetVal;
8252 break;
8253 case lltok::kw_virtualConstProp:
8254 ByArg.TheKind = WholeProgramDevirtResolution::ByArg::VirtualConstProp;
8255 break;
8256 default:
8257 return error(Lex.getLoc(),
8258 "unexpected WholeProgramDevirtResolution::ByArg kind");
8259 }
8260 Lex.Lex();
8261
8262 // parse optional fields
8263 while (EatIfPresent(lltok::comma)) {
8264 switch (Lex.getKind()) {
8265 case lltok::kw_info:
8266 Lex.Lex();
8267 if (parseToken(lltok::colon, "expected ':' here") ||
8268 parseUInt64(ByArg.Info))
8269 return true;
8270 break;
8271 case lltok::kw_byte:
8272 Lex.Lex();
8273 if (parseToken(lltok::colon, "expected ':' here") ||
8274 parseUInt32(ByArg.Byte))
8275 return true;
8276 break;
8277 case lltok::kw_bit:
8278 Lex.Lex();
8279 if (parseToken(lltok::colon, "expected ':' here") ||
8280 parseUInt32(ByArg.Bit))
8281 return true;
8282 break;
8283 default:
8284 return error(Lex.getLoc(),
8285 "expected optional whole program devirt field");
8286 }
8287 }
8288
8289 if (parseToken(lltok::rparen, "expected ')' here"))
8290 return true;
8291
8292 ResByArg[Args] = ByArg;
8293 } while (EatIfPresent(lltok::comma));
8294
8295 if (parseToken(lltok::rparen, "expected ')' here"))
8296 return true;
8297
8298 return false;
8299}
8300
8301/// OptionalResByArg
8302/// ::= 'args' ':' '(' UInt64[, UInt64]* ')'
8303bool LLParser::parseArgs(std::vector<uint64_t> &Args) {
8304 if (parseToken(lltok::kw_args, "expected 'args' here") ||
8305 parseToken(lltok::colon, "expected ':' here") ||
8306 parseToken(lltok::lparen, "expected '(' here"))
8307 return true;
8308
8309 do {
8310 uint64_t Val;
8311 if (parseUInt64(Val))
8312 return true;
8313 Args.push_back(Val);
8314 } while (EatIfPresent(lltok::comma));
8315
8316 if (parseToken(lltok::rparen, "expected ')' here"))
8317 return true;
8318
8319 return false;
8320}
8321
8322static const auto FwdVIRef = (GlobalValueSummaryMapTy::value_type *)-8;
8323
8324static void resolveFwdRef(ValueInfo *Fwd, ValueInfo &Resolved) {
8325 bool ReadOnly = Fwd->isReadOnly();
8326 bool WriteOnly = Fwd->isWriteOnly();
8327 assert(!(ReadOnly && WriteOnly));
8328 *Fwd = Resolved;
8329 if (ReadOnly)
8330 Fwd->setReadOnly();
8331 if (WriteOnly)
8332 Fwd->setWriteOnly();
8333}
8334
8335/// Stores the given Name/GUID and associated summary into the Index.
8336/// Also updates any forward references to the associated entry ID.
8337void LLParser::addGlobalValueToIndex(
8338 std::string Name, GlobalValue::GUID GUID, GlobalValue::LinkageTypes Linkage,
8339 unsigned ID, std::unique_ptr<GlobalValueSummary> Summary) {
8340 // First create the ValueInfo utilizing the Name or GUID.
8341 ValueInfo VI;
8342 if (GUID != 0) {
8343 assert(Name.empty());
8344 VI = Index->getOrInsertValueInfo(GUID);
8345 } else {
8346 assert(!Name.empty());
8347 if (M) {
8348 auto *GV = M->getNamedValue(Name);
8349 assert(GV);
8350 VI = Index->getOrInsertValueInfo(GV);
8351 } else {
8352 assert(
8353 (!GlobalValue::isLocalLinkage(Linkage) || !SourceFileName.empty()) &&
8354 "Need a source_filename to compute GUID for local");
8355 GUID = GlobalValue::getGUID(
8356 GlobalValue::getGlobalIdentifier(Name, Linkage, SourceFileName));
8357 VI = Index->getOrInsertValueInfo(GUID, Index->saveString(Name));
8358 }
8359 }
8360
8361 // Resolve forward references from calls/refs
8362 auto FwdRefVIs = ForwardRefValueInfos.find(ID);
8363 if (FwdRefVIs != ForwardRefValueInfos.end()) {
8364 for (auto VIRef : FwdRefVIs->second) {
8365 assert(VIRef.first->getRef() == FwdVIRef &&
8366 "Forward referenced ValueInfo expected to be empty");
8367 resolveFwdRef(VIRef.first, VI);
8368 }
8369 ForwardRefValueInfos.erase(FwdRefVIs);
8370 }
8371
8372 // Resolve forward references from aliases
8373 auto FwdRefAliasees = ForwardRefAliasees.find(ID);
8374 if (FwdRefAliasees != ForwardRefAliasees.end()) {
8375 for (auto AliaseeRef : FwdRefAliasees->second) {
8376 assert(!AliaseeRef.first->hasAliasee() &&
8377 "Forward referencing alias already has aliasee");
8378 assert(Summary && "Aliasee must be a definition");
8379 AliaseeRef.first->setAliasee(VI, Summary.get());
8380 }
8381 ForwardRefAliasees.erase(FwdRefAliasees);
8382 }
8383
8384 // Add the summary if one was provided.
8385 if (Summary)
8386 Index->addGlobalValueSummary(VI, std::move(Summary));
8387
8388 // Save the associated ValueInfo for use in later references by ID.
8389 if (ID == NumberedValueInfos.size())
8390 NumberedValueInfos.push_back(VI);
8391 else {
8392 // Handle non-continuous numbers (to make test simplification easier).
8393 if (ID > NumberedValueInfos.size())
8394 NumberedValueInfos.resize(ID + 1);
8395 NumberedValueInfos[ID] = VI;
8396 }
8397}
8398
8399/// parseSummaryIndexFlags
8400/// ::= 'flags' ':' UInt64
8401bool LLParser::parseSummaryIndexFlags() {
8402 assert(Lex.getKind() == lltok::kw_flags);
8403 Lex.Lex();
8404
8405 if (parseToken(lltok::colon, "expected ':' here"))
8406 return true;
8407 uint64_t Flags;
8408 if (parseUInt64(Flags))
8409 return true;
8410 if (Index)
8411 Index->setFlags(Flags);
8412 return false;
8413}
8414
8415/// parseBlockCount
8416/// ::= 'blockcount' ':' UInt64
8417bool LLParser::parseBlockCount() {
8418 assert(Lex.getKind() == lltok::kw_blockcount);
8419 Lex.Lex();
8420
8421 if (parseToken(lltok::colon, "expected ':' here"))
8422 return true;
8423 uint64_t BlockCount;
8424 if (parseUInt64(BlockCount))
8425 return true;
8426 if (Index)
8427 Index->setBlockCount(BlockCount);
8428 return false;
8429}
8430
8431/// parseGVEntry
8432/// ::= 'gv' ':' '(' ('name' ':' STRINGCONSTANT | 'guid' ':' UInt64)
8433/// [',' 'summaries' ':' Summary[',' Summary]* ]? ')'
8434/// Summary ::= '(' (FunctionSummary | VariableSummary | AliasSummary) ')'
8435bool LLParser::parseGVEntry(unsigned ID) {
8436 assert(Lex.getKind() == lltok::kw_gv);
8437 Lex.Lex();
8438
8439 if (parseToken(lltok::colon, "expected ':' here") ||
8440 parseToken(lltok::lparen, "expected '(' here"))
8441 return true;
8442
8443 std::string Name;
8444 GlobalValue::GUID GUID = 0;
8445 switch (Lex.getKind()) {
8446 case lltok::kw_name:
8447 Lex.Lex();
8448 if (parseToken(lltok::colon, "expected ':' here") ||
8449 parseStringConstant(Name))
8450 return true;
8451 // Can't create GUID/ValueInfo until we have the linkage.
8452 break;
8453 case lltok::kw_guid:
8454 Lex.Lex();
8455 if (parseToken(lltok::colon, "expected ':' here") || parseUInt64(GUID))
8456 return true;
8457 break;
8458 default:
8459 return error(Lex.getLoc(), "expected name or guid tag");
8460 }
8461
8462 if (!EatIfPresent(lltok::comma)) {
8463 // No summaries. Wrap up.
8464 if (parseToken(lltok::rparen, "expected ')' here"))
8465 return true;
8466 // This was created for a call to an external or indirect target.
8467 // A GUID with no summary came from a VALUE_GUID record, dummy GUID
8468 // created for indirect calls with VP. A Name with no GUID came from
8469 // an external definition. We pass ExternalLinkage since that is only
8470 // used when the GUID must be computed from Name, and in that case
8471 // the symbol must have external linkage.
8472 addGlobalValueToIndex(Name, GUID, GlobalValue::ExternalLinkage, ID,
8473 nullptr);
8474 return false;
8475 }
8476
8477 // Have a list of summaries
8478 if (parseToken(lltok::kw_summaries, "expected 'summaries' here") ||
8479 parseToken(lltok::colon, "expected ':' here") ||
8480 parseToken(lltok::lparen, "expected '(' here"))
8481 return true;
8482 do {
8483 switch (Lex.getKind()) {
8484 case lltok::kw_function:
8485 if (parseFunctionSummary(Name, GUID, ID))
8486 return true;
8487 break;
8488 case lltok::kw_variable:
8489 if (parseVariableSummary(Name, GUID, ID))
8490 return true;
8491 break;
8492 case lltok::kw_alias:
8493 if (parseAliasSummary(Name, GUID, ID))
8494 return true;
8495 break;
8496 default:
8497 return error(Lex.getLoc(), "expected summary type");
8498 }
8499 } while (EatIfPresent(lltok::comma));
8500
8501 if (parseToken(lltok::rparen, "expected ')' here") ||
8502 parseToken(lltok::rparen, "expected ')' here"))
8503 return true;
8504
8505 return false;
8506}
8507
8508/// FunctionSummary
8509/// ::= 'function' ':' '(' 'module' ':' ModuleReference ',' GVFlags
8510/// ',' 'insts' ':' UInt32 [',' OptionalFFlags]? [',' OptionalCalls]?
8511/// [',' OptionalTypeIdInfo]? [',' OptionalParamAccesses]?
8512/// [',' OptionalRefs]? ')'
8513bool LLParser::parseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
8514 unsigned ID) {
8515 assert(Lex.getKind() == lltok::kw_function);
8516 Lex.Lex();
8517
8518 StringRef ModulePath;
8519 GlobalValueSummary::GVFlags GVFlags = GlobalValueSummary::GVFlags(
8520 /*Linkage=*/GlobalValue::ExternalLinkage, /*NotEligibleToImport=*/false,
8521 /*Live=*/false, /*IsLocal=*/false, /*CanAutoHide=*/false);
8522 unsigned InstCount;
8523 std::vector<FunctionSummary::EdgeTy> Calls;
8524 FunctionSummary::TypeIdInfo TypeIdInfo;
8525 std::vector<FunctionSummary::ParamAccess> ParamAccesses;
8526 std::vector<ValueInfo> Refs;
8527 // Default is all-zeros (conservative values).
8528 FunctionSummary::FFlags FFlags = {};
8529 if (parseToken(lltok::colon, "expected ':' here") ||
8530 parseToken(lltok::lparen, "expected '(' here") ||
8531 parseModuleReference(ModulePath) ||
8532 parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
8533 parseToken(lltok::comma, "expected ',' here") ||
8534 parseToken(lltok::kw_insts, "expected 'insts' here") ||
8535 parseToken(lltok::colon, "expected ':' here") || parseUInt32(InstCount))
8536 return true;
8537
8538 // parse optional fields
8539 while (EatIfPresent(lltok::comma)) {
8540 switch (Lex.getKind()) {
8541 case lltok::kw_funcFlags:
8542 if (parseOptionalFFlags(FFlags))
8543 return true;
8544 break;
8545 case lltok::kw_calls:
8546 if (parseOptionalCalls(Calls))
8547 return true;
8548 break;
8549 case lltok::kw_typeIdInfo:
8550 if (parseOptionalTypeIdInfo(TypeIdInfo))
8551 return true;
8552 break;
8553 case lltok::kw_refs:
8554 if (parseOptionalRefs(Refs))
8555 return true;
8556 break;
8557 case lltok::kw_params:
8558 if (parseOptionalParamAccesses(ParamAccesses))
8559 return true;
8560 break;
8561 default:
8562 return error(Lex.getLoc(), "expected optional function summary field");
8563 }
8564 }
8565
8566 if (parseToken(lltok::rparen, "expected ')' here"))
8567 return true;
8568
8569 auto FS = std::make_unique<FunctionSummary>(
8570 GVFlags, InstCount, FFlags, /*EntryCount=*/0, std::move(Refs),
8571 std::move(Calls), std::move(TypeIdInfo.TypeTests),
8572 std::move(TypeIdInfo.TypeTestAssumeVCalls),
8573 std::move(TypeIdInfo.TypeCheckedLoadVCalls),
8574 std::move(TypeIdInfo.TypeTestAssumeConstVCalls),
8575 std::move(TypeIdInfo.TypeCheckedLoadConstVCalls),
8576 std::move(ParamAccesses));
8577
8578 FS->setModulePath(ModulePath);
8579
8580 addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
8581 ID, std::move(FS));
8582
8583 return false;
8584}
8585
8586/// VariableSummary
8587/// ::= 'variable' ':' '(' 'module' ':' ModuleReference ',' GVFlags
8588/// [',' OptionalRefs]? ')'
8589bool LLParser::parseVariableSummary(std::string Name, GlobalValue::GUID GUID,
8590 unsigned ID) {
8591 assert(Lex.getKind() == lltok::kw_variable);
8592 Lex.Lex();
8593
8594 StringRef ModulePath;
8595 GlobalValueSummary::GVFlags GVFlags = GlobalValueSummary::GVFlags(
8596 /*Linkage=*/GlobalValue::ExternalLinkage, /*NotEligibleToImport=*/false,
8597 /*Live=*/false, /*IsLocal=*/false, /*CanAutoHide=*/false);
8598 GlobalVarSummary::GVarFlags GVarFlags(/*ReadOnly*/ false,
8599 /* WriteOnly */ false,
8600 /* Constant */ false,
8601 GlobalObject::VCallVisibilityPublic);
8602 std::vector<ValueInfo> Refs;
8603 VTableFuncList VTableFuncs;
8604 if (parseToken(lltok::colon, "expected ':' here") ||
8605 parseToken(lltok::lparen, "expected '(' here") ||
8606 parseModuleReference(ModulePath) ||
8607 parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
8608 parseToken(lltok::comma, "expected ',' here") ||
8609 parseGVarFlags(GVarFlags))
8610 return true;
8611
8612 // parse optional fields
8613 while (EatIfPresent(lltok::comma)) {
8614 switch (Lex.getKind()) {
8615 case lltok::kw_vTableFuncs:
8616 if (parseOptionalVTableFuncs(VTableFuncs))
8617 return true;
8618 break;
8619 case lltok::kw_refs:
8620 if (parseOptionalRefs(Refs))
8621 return true;
8622 break;
8623 default:
8624 return error(Lex.getLoc(), "expected optional variable summary field");
8625 }
8626 }
8627
8628 if (parseToken(lltok::rparen, "expected ')' here"))
8629 return true;
8630
8631 auto GS =
8632 std::make_unique<GlobalVarSummary>(GVFlags, GVarFlags, std::move(Refs));
8633
8634 GS->setModulePath(ModulePath);
8635 GS->setVTableFuncs(std::move(VTableFuncs));
8636
8637 addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
8638 ID, std::move(GS));
8639
8640 return false;
8641}
8642
8643/// AliasSummary
8644/// ::= 'alias' ':' '(' 'module' ':' ModuleReference ',' GVFlags ','
8645/// 'aliasee' ':' GVReference ')'
8646bool LLParser::parseAliasSummary(std::string Name, GlobalValue::GUID GUID,
8647 unsigned ID) {
8648 assert(Lex.getKind() == lltok::kw_alias);
8649 LocTy Loc = Lex.getLoc();
8650 Lex.Lex();
8651
8652 StringRef ModulePath;
8653 GlobalValueSummary::GVFlags GVFlags = GlobalValueSummary::GVFlags(
8654 /*Linkage=*/GlobalValue::ExternalLinkage, /*NotEligibleToImport=*/false,
8655 /*Live=*/false, /*IsLocal=*/false, /*CanAutoHide=*/false);
8656 if (parseToken(lltok::colon, "expected ':' here") ||
8657 parseToken(lltok::lparen, "expected '(' here") ||
8658 parseModuleReference(ModulePath) ||
8659 parseToken(lltok::comma, "expected ',' here") || parseGVFlags(GVFlags) ||
8660 parseToken(lltok::comma, "expected ',' here") ||
8661 parseToken(lltok::kw_aliasee, "expected 'aliasee' here") ||
8662 parseToken(lltok::colon, "expected ':' here"))
8663 return true;
8664
8665 ValueInfo AliaseeVI;
8666 unsigned GVId;
8667 if (parseGVReference(AliaseeVI, GVId))
8668 return true;
8669
8670 if (parseToken(lltok::rparen, "expected ')' here"))
8671 return true;
8672
8673 auto AS = std::make_unique<AliasSummary>(GVFlags);
8674
8675 AS->setModulePath(ModulePath);
8676
8677 // Record forward reference if the aliasee is not parsed yet.
8678 if (AliaseeVI.getRef() == FwdVIRef) {
8679 ForwardRefAliasees[GVId].emplace_back(AS.get(), Loc);
8680 } else {
8681 auto Summary = Index->findSummaryInModule(AliaseeVI, ModulePath);
8682 assert(Summary && "Aliasee must be a definition");
8683 AS->setAliasee(AliaseeVI, Summary);
8684 }
8685
8686 addGlobalValueToIndex(Name, GUID, (GlobalValue::LinkageTypes)GVFlags.Linkage,
8687 ID, std::move(AS));
8688
8689 return false;
8690}
8691
8692/// Flag
8693/// ::= [0|1]
8694bool LLParser::parseFlag(unsigned &Val) {
8695 if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
8696 return tokError("expected integer");
8697 Val = (unsigned)Lex.getAPSIntVal().getBoolValue();
8698 Lex.Lex();
8699 return false;
8700}
8701
8702/// OptionalFFlags
8703/// := 'funcFlags' ':' '(' ['readNone' ':' Flag]?
8704/// [',' 'readOnly' ':' Flag]? [',' 'noRecurse' ':' Flag]?
8705/// [',' 'returnDoesNotAlias' ':' Flag]? ')'
8706/// [',' 'noInline' ':' Flag]? ')'
8707/// [',' 'alwaysInline' ':' Flag]? ')'
8708
8709bool LLParser::parseOptionalFFlags(FunctionSummary::FFlags &FFlags) {
8710 assert(Lex.getKind() == lltok::kw_funcFlags);
8711 Lex.Lex();
8712
8713 if (parseToken(lltok::colon, "expected ':' in funcFlags") |
8714 parseToken(lltok::lparen, "expected '(' in funcFlags"))
8715 return true;
8716
8717 do {
8718 unsigned Val = 0;
8719 switch (Lex.getKind()) {
8720 case lltok::kw_readNone:
8721 Lex.Lex();
8722 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8723 return true;
8724 FFlags.ReadNone = Val;
8725 break;
8726 case lltok::kw_readOnly:
8727 Lex.Lex();
8728 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8729 return true;
8730 FFlags.ReadOnly = Val;
8731 break;
8732 case lltok::kw_noRecurse:
8733 Lex.Lex();
8734 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8735 return true;
8736 FFlags.NoRecurse = Val;
8737 break;
8738 case lltok::kw_returnDoesNotAlias:
8739 Lex.Lex();
8740 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8741 return true;
8742 FFlags.ReturnDoesNotAlias = Val;
8743 break;
8744 case lltok::kw_noInline:
8745 Lex.Lex();
8746 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8747 return true;
8748 FFlags.NoInline = Val;
8749 break;
8750 case lltok::kw_alwaysInline:
8751 Lex.Lex();
8752 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Val))
8753 return true;
8754 FFlags.AlwaysInline = Val;
8755 break;
8756 default:
8757 return error(Lex.getLoc(), "expected function flag type");
8758 }
8759 } while (EatIfPresent(lltok::comma));
8760
8761 if (parseToken(lltok::rparen, "expected ')' in funcFlags"))
8762 return true;
8763
8764 return false;
8765}
8766
8767/// OptionalCalls
8768/// := 'calls' ':' '(' Call [',' Call]* ')'
8769/// Call ::= '(' 'callee' ':' GVReference
8770/// [( ',' 'hotness' ':' Hotness | ',' 'relbf' ':' UInt32 )]? ')'
8771bool LLParser::parseOptionalCalls(std::vector<FunctionSummary::EdgeTy> &Calls) {
8772 assert(Lex.getKind() == lltok::kw_calls);
8773 Lex.Lex();
8774
8775 if (parseToken(lltok::colon, "expected ':' in calls") |
8776 parseToken(lltok::lparen, "expected '(' in calls"))
8777 return true;
8778
8779 IdToIndexMapType IdToIndexMap;
8780 // parse each call edge
8781 do {
8782 ValueInfo VI;
8783 if (parseToken(lltok::lparen, "expected '(' in call") ||
8784 parseToken(lltok::kw_callee, "expected 'callee' in call") ||
8785 parseToken(lltok::colon, "expected ':'"))
8786 return true;
8787
8788 LocTy Loc = Lex.getLoc();
8789 unsigned GVId;
8790 if (parseGVReference(VI, GVId))
8791 return true;
8792
8793 CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;
8794 unsigned RelBF = 0;
8795 if (EatIfPresent(lltok::comma)) {
8796 // Expect either hotness or relbf
8797 if (EatIfPresent(lltok::kw_hotness)) {
8798 if (parseToken(lltok::colon, "expected ':'") || parseHotness(Hotness))
8799 return true;
8800 } else {
8801 if (parseToken(lltok::kw_relbf, "expected relbf") ||
8802 parseToken(lltok::colon, "expected ':'") || parseUInt32(RelBF))
8803 return true;
8804 }
8805 }
8806 // Keep track of the Call array index needing a forward reference.
8807 // We will save the location of the ValueInfo needing an update, but
8808 // can only do so once the std::vector is finalized.
8809 if (VI.getRef() == FwdVIRef)
8810 IdToIndexMap[GVId].push_back(std::make_pair(Calls.size(), Loc));
8811 Calls.push_back(FunctionSummary::EdgeTy{VI, CalleeInfo(Hotness, RelBF)});
8812
8813 if (parseToken(lltok::rparen, "expected ')' in call"))
8814 return true;
8815 } while (EatIfPresent(lltok::comma));
8816
8817 // Now that the Calls vector is finalized, it is safe to save the locations
8818 // of any forward GV references that need updating later.
8819 for (auto I : IdToIndexMap) {
8820 auto &Infos = ForwardRefValueInfos[I.first];
8821 for (auto P : I.second) {
8822 assert(Calls[P.first].first.getRef() == FwdVIRef &&
8823 "Forward referenced ValueInfo expected to be empty");
8824 Infos.emplace_back(&Calls[P.first].first, P.second);
8825 }
8826 }
8827
8828 if (parseToken(lltok::rparen, "expected ')' in calls"))
8829 return true;
8830
8831 return false;
8832}
8833
8834/// Hotness
8835/// := ('unknown'|'cold'|'none'|'hot'|'critical')
8836bool LLParser::parseHotness(CalleeInfo::HotnessType &Hotness) {
8837 switch (Lex.getKind()) {
8838 case lltok::kw_unknown:
8839 Hotness = CalleeInfo::HotnessType::Unknown;
8840 break;
8841 case lltok::kw_cold:
8842 Hotness = CalleeInfo::HotnessType::Cold;
8843 break;
8844 case lltok::kw_none:
8845 Hotness = CalleeInfo::HotnessType::None;
8846 break;
8847 case lltok::kw_hot:
8848 Hotness = CalleeInfo::HotnessType::Hot;
8849 break;
8850 case lltok::kw_critical:
8851 Hotness = CalleeInfo::HotnessType::Critical;
8852 break;
8853 default:
8854 return error(Lex.getLoc(), "invalid call edge hotness");
8855 }
8856 Lex.Lex();
8857 return false;
8858}
8859
8860/// OptionalVTableFuncs
8861/// := 'vTableFuncs' ':' '(' VTableFunc [',' VTableFunc]* ')'
8862/// VTableFunc ::= '(' 'virtFunc' ':' GVReference ',' 'offset' ':' UInt64 ')'
8863bool LLParser::parseOptionalVTableFuncs(VTableFuncList &VTableFuncs) {
8864 assert(Lex.getKind() == lltok::kw_vTableFuncs);
8865 Lex.Lex();
8866
8867 if (parseToken(lltok::colon, "expected ':' in vTableFuncs") |
8868 parseToken(lltok::lparen, "expected '(' in vTableFuncs"))
8869 return true;
8870
8871 IdToIndexMapType IdToIndexMap;
8872 // parse each virtual function pair
8873 do {
8874 ValueInfo VI;
8875 if (parseToken(lltok::lparen, "expected '(' in vTableFunc") ||
8876 parseToken(lltok::kw_virtFunc, "expected 'callee' in vTableFunc") ||
8877 parseToken(lltok::colon, "expected ':'"))
8878 return true;
8879
8880 LocTy Loc = Lex.getLoc();
8881 unsigned GVId;
8882 if (parseGVReference(VI, GVId))
8883 return true;
8884
8885 uint64_t Offset;
8886 if (parseToken(lltok::comma, "expected comma") ||
8887 parseToken(lltok::kw_offset, "expected offset") ||
8888 parseToken(lltok::colon, "expected ':'") || parseUInt64(Offset))
8889 return true;
8890
8891 // Keep track of the VTableFuncs array index needing a forward reference.
8892 // We will save the location of the ValueInfo needing an update, but
8893 // can only do so once the std::vector is finalized.
8894 if (VI == EmptyVI)
8895 IdToIndexMap[GVId].push_back(std::make_pair(VTableFuncs.size(), Loc));
8896 VTableFuncs.push_back({VI, Offset});
8897
8898 if (parseToken(lltok::rparen, "expected ')' in vTableFunc"))
8899 return true;
8900 } while (EatIfPresent(lltok::comma));
8901
8902 // Now that the VTableFuncs vector is finalized, it is safe to save the
8903 // locations of any forward GV references that need updating later.
8904 for (auto I : IdToIndexMap) {
8905 auto &Infos = ForwardRefValueInfos[I.first];
8906 for (auto P : I.second) {
8907 assert(VTableFuncs[P.first].FuncVI == EmptyVI &&
8908 "Forward referenced ValueInfo expected to be empty");
8909 Infos.emplace_back(&VTableFuncs[P.first].FuncVI, P.second);
8910 }
8911 }
8912
8913 if (parseToken(lltok::rparen, "expected ')' in vTableFuncs"))
8914 return true;
8915
8916 return false;
8917}
8918
8919/// ParamNo := 'param' ':' UInt64
8920bool LLParser::parseParamNo(uint64_t &ParamNo) {
8921 if (parseToken(lltok::kw_param, "expected 'param' here") ||
8922 parseToken(lltok::colon, "expected ':' here") || parseUInt64(ParamNo))
8923 return true;
8924 return false;
8925}
8926
8927/// ParamAccessOffset := 'offset' ':' '[' APSINTVAL ',' APSINTVAL ']'
8928bool LLParser::parseParamAccessOffset(ConstantRange &Range) {
8929 APSInt Lower;
8930 APSInt Upper;
8931 auto ParseAPSInt = [&](APSInt &Val) {
8932 if (Lex.getKind() != lltok::APSInt)
8933 return tokError("expected integer");
8934 Val = Lex.getAPSIntVal();
8935 Val = Val.extOrTrunc(FunctionSummary::ParamAccess::RangeWidth);
8936 Val.setIsSigned(true);
8937 Lex.Lex();
8938 return false;
8939 };
8940 if (parseToken(lltok::kw_offset, "expected 'offset' here") ||
8941 parseToken(lltok::colon, "expected ':' here") ||
8942 parseToken(lltok::lsquare, "expected '[' here") || ParseAPSInt(Lower) ||
8943 parseToken(lltok::comma, "expected ',' here") || ParseAPSInt(Upper) ||
8944 parseToken(lltok::rsquare, "expected ']' here"))
8945 return true;
8946
8947 ++Upper;
8948 Range =
8949 (Lower == Upper && !Lower.isMaxValue())
8950 ? ConstantRange::getEmpty(FunctionSummary::ParamAccess::RangeWidth)
8951 : ConstantRange(Lower, Upper);
8952
8953 return false;
8954}
8955
8956/// ParamAccessCall
8957/// := '(' 'callee' ':' GVReference ',' ParamNo ',' ParamAccessOffset ')'
8958bool LLParser::parseParamAccessCall(FunctionSummary::ParamAccess::Call &Call,
8959 IdLocListType &IdLocList) {
8960 if (parseToken(lltok::lparen, "expected '(' here") ||
8961 parseToken(lltok::kw_callee, "expected 'callee' here") ||
8962 parseToken(lltok::colon, "expected ':' here"))
8963 return true;
8964
8965 unsigned GVId;
8966 ValueInfo VI;
8967 LocTy Loc = Lex.getLoc();
8968 if (parseGVReference(VI, GVId))
8969 return true;
8970
8971 Call.Callee = VI;
8972 IdLocList.emplace_back(GVId, Loc);
8973
8974 if (parseToken(lltok::comma, "expected ',' here") ||
8975 parseParamNo(Call.ParamNo) ||
8976 parseToken(lltok::comma, "expected ',' here") ||
8977 parseParamAccessOffset(Call.Offsets))
8978 return true;
8979
8980 if (parseToken(lltok::rparen, "expected ')' here"))
8981 return true;
8982
8983 return false;
8984}
8985
8986/// ParamAccess
8987/// := '(' ParamNo ',' ParamAccessOffset [',' OptionalParamAccessCalls]? ')'
8988/// OptionalParamAccessCalls := '(' Call [',' Call]* ')'
8989bool LLParser::parseParamAccess(FunctionSummary::ParamAccess &Param,
8990 IdLocListType &IdLocList) {
8991 if (parseToken(lltok::lparen, "expected '(' here") ||
8992 parseParamNo(Param.ParamNo) ||
8993 parseToken(lltok::comma, "expected ',' here") ||
8994 parseParamAccessOffset(Param.Use))
8995 return true;
8996
8997 if (EatIfPresent(lltok::comma)) {
8998 if (parseToken(lltok::kw_calls, "expected 'calls' here") ||
8999 parseToken(lltok::colon, "expected ':' here") ||
9000 parseToken(lltok::lparen, "expected '(' here"))
9001 return true;
9002 do {
9003 FunctionSummary::ParamAccess::Call Call;
9004 if (parseParamAccessCall(Call, IdLocList))
9005 return true;
9006 Param.Calls.push_back(Call);
9007 } while (EatIfPresent(lltok::comma));
9008
9009 if (parseToken(lltok::rparen, "expected ')' here"))
9010 return true;
9011 }
9012
9013 if (parseToken(lltok::rparen, "expected ')' here"))
9014 return true;
9015
9016 return false;
9017}
9018
9019/// OptionalParamAccesses
9020/// := 'params' ':' '(' ParamAccess [',' ParamAccess]* ')'
9021bool LLParser::parseOptionalParamAccesses(
9022 std::vector<FunctionSummary::ParamAccess> &Params) {
9023 assert(Lex.getKind() == lltok::kw_params);
9024 Lex.Lex();
9025
9026 if (parseToken(lltok::colon, "expected ':' here") ||
9027 parseToken(lltok::lparen, "expected '(' here"))
9028 return true;
9029
9030 IdLocListType VContexts;
9031 size_t CallsNum = 0;
9032 do {
9033 FunctionSummary::ParamAccess ParamAccess;
9034 if (parseParamAccess(ParamAccess, VContexts))
9035 return true;
9036 CallsNum += ParamAccess.Calls.size();
9037 assert(VContexts.size() == CallsNum);
9038 Params.emplace_back(std::move(ParamAccess));
9039 } while (EatIfPresent(lltok::comma));
9040
9041 if (parseToken(lltok::rparen, "expected ')' here"))
9042 return true;
9043
9044 // Now that the Params is finalized, it is safe to save the locations
9045 // of any forward GV references that need updating later.
9046 IdLocListType::const_iterator ItContext = VContexts.begin();
9047 for (auto &PA : Params) {
9048 for (auto &C : PA.Calls) {
9049 if (C.Callee.getRef() == FwdVIRef)
9050 ForwardRefValueInfos[ItContext->first].emplace_back(&C.Callee,
9051 ItContext->second);
9052 ++ItContext;
9053 }
9054 }
9055 assert(ItContext == VContexts.end());
9056
9057 return false;
9058}
9059
9060/// OptionalRefs
9061/// := 'refs' ':' '(' GVReference [',' GVReference]* ')'
9062bool LLParser::parseOptionalRefs(std::vector<ValueInfo> &Refs) {
9063 assert(Lex.getKind() == lltok::kw_refs);
9064 Lex.Lex();
9065
9066 if (parseToken(lltok::colon, "expected ':' in refs") ||
9067 parseToken(lltok::lparen, "expected '(' in refs"))
9068 return true;
9069
9070 struct ValueContext {
9071 ValueInfo VI;
9072 unsigned GVId;
9073 LocTy Loc;
9074 };
9075 std::vector<ValueContext> VContexts;
9076 // parse each ref edge
9077 do {
9078 ValueContext VC;
9079 VC.Loc = Lex.getLoc();
9080 if (parseGVReference(VC.VI, VC.GVId))
9081 return true;
9082 VContexts.push_back(VC);
9083 } while (EatIfPresent(lltok::comma));
9084
9085 // Sort value contexts so that ones with writeonly
9086 // and readonly ValueInfo are at the end of VContexts vector.
9087 // See FunctionSummary::specialRefCounts()
9088 llvm::sort(VContexts, [](const ValueContext &VC1, const ValueContext &VC2) {
9089 return VC1.VI.getAccessSpecifier() < VC2.VI.getAccessSpecifier();
9090 });
9091
9092 IdToIndexMapType IdToIndexMap;
9093 for (auto &VC : VContexts) {
9094 // Keep track of the Refs array index needing a forward reference.
9095 // We will save the location of the ValueInfo needing an update, but
9096 // can only do so once the std::vector is finalized.
9097 if (VC.VI.getRef() == FwdVIRef)
9098 IdToIndexMap[VC.GVId].push_back(std::make_pair(Refs.size(), VC.Loc));
9099 Refs.push_back(VC.VI);
9100 }
9101
9102 // Now that the Refs vector is finalized, it is safe to save the locations
9103 // of any forward GV references that need updating later.
9104 for (auto I : IdToIndexMap) {
9105 auto &Infos = ForwardRefValueInfos[I.first];
9106 for (auto P : I.second) {
9107 assert(Refs[P.first].getRef() == FwdVIRef &&
9108 "Forward referenced ValueInfo expected to be empty");
9109 Infos.emplace_back(&Refs[P.first], P.second);
9110 }
9111 }
9112
9113 if (parseToken(lltok::rparen, "expected ')' in refs"))
9114 return true;
9115
9116 return false;
9117}
9118
9119/// OptionalTypeIdInfo
9120/// := 'typeidinfo' ':' '(' [',' TypeTests]? [',' TypeTestAssumeVCalls]?
9121/// [',' TypeCheckedLoadVCalls]? [',' TypeTestAssumeConstVCalls]?
9122/// [',' TypeCheckedLoadConstVCalls]? ')'
9123bool LLParser::parseOptionalTypeIdInfo(
9124 FunctionSummary::TypeIdInfo &TypeIdInfo) {
9125 assert(Lex.getKind() == lltok::kw_typeIdInfo);
9126 Lex.Lex();
9127
9128 if (parseToken(lltok::colon, "expected ':' here") ||
9129 parseToken(lltok::lparen, "expected '(' in typeIdInfo"))
9130 return true;
9131
9132 do {
9133 switch (Lex.getKind()) {
9134 case lltok::kw_typeTests:
9135 if (parseTypeTests(TypeIdInfo.TypeTests))
9136 return true;
9137 break;
9138 case lltok::kw_typeTestAssumeVCalls:
9139 if (parseVFuncIdList(lltok::kw_typeTestAssumeVCalls,
9140 TypeIdInfo.TypeTestAssumeVCalls))
9141 return true;
9142 break;
9143 case lltok::kw_typeCheckedLoadVCalls:
9144 if (parseVFuncIdList(lltok::kw_typeCheckedLoadVCalls,
9145 TypeIdInfo.TypeCheckedLoadVCalls))
9146 return true;
9147 break;
9148 case lltok::kw_typeTestAssumeConstVCalls:
9149 if (parseConstVCallList(lltok::kw_typeTestAssumeConstVCalls,
9150 TypeIdInfo.TypeTestAssumeConstVCalls))
9151 return true;
9152 break;
9153 case lltok::kw_typeCheckedLoadConstVCalls:
9154 if (parseConstVCallList(lltok::kw_typeCheckedLoadConstVCalls,
9155 TypeIdInfo.TypeCheckedLoadConstVCalls))
9156 return true;
9157 break;
9158 default:
9159 return error(Lex.getLoc(), "invalid typeIdInfo list type");
9160 }
9161 } while (EatIfPresent(lltok::comma));
9162
9163 if (parseToken(lltok::rparen, "expected ')' in typeIdInfo"))
9164 return true;
9165
9166 return false;
9167}
9168
9169/// TypeTests
9170/// ::= 'typeTests' ':' '(' (SummaryID | UInt64)
9171/// [',' (SummaryID | UInt64)]* ')'
9172bool LLParser::parseTypeTests(std::vector<GlobalValue::GUID> &TypeTests) {
9173 assert(Lex.getKind() == lltok::kw_typeTests);
9174 Lex.Lex();
9175
9176 if (parseToken(lltok::colon, "expected ':' here") ||
9177 parseToken(lltok::lparen, "expected '(' in typeIdInfo"))
9178 return true;
9179
9180 IdToIndexMapType IdToIndexMap;
9181 do {
9182 GlobalValue::GUID GUID = 0;
9183 if (Lex.getKind() == lltok::SummaryID) {
9184 unsigned ID = Lex.getUIntVal();
9185 LocTy Loc = Lex.getLoc();
9186 // Keep track of the TypeTests array index needing a forward reference.
9187 // We will save the location of the GUID needing an update, but
9188 // can only do so once the std::vector is finalized.
9189 IdToIndexMap[ID].push_back(std::make_pair(TypeTests.size(), Loc));
9190 Lex.Lex();
9191 } else if (parseUInt64(GUID))
9192 return true;
9193 TypeTests.push_back(GUID);
9194 } while (EatIfPresent(lltok::comma));
9195
9196 // Now that the TypeTests vector is finalized, it is safe to save the
9197 // locations of any forward GV references that need updating later.
9198 for (auto I : IdToIndexMap) {
9199 auto &Ids = ForwardRefTypeIds[I.first];
9200 for (auto P : I.second) {
9201 assert(TypeTests[P.first] == 0 &&
9202 "Forward referenced type id GUID expected to be 0");
9203 Ids.emplace_back(&TypeTests[P.first], P.second);
9204 }
9205 }
9206
9207 if (parseToken(lltok::rparen, "expected ')' in typeIdInfo"))
9208 return true;
9209
9210 return false;
9211}
9212
9213/// VFuncIdList
9214/// ::= Kind ':' '(' VFuncId [',' VFuncId]* ')'
9215bool LLParser::parseVFuncIdList(
9216 lltok::Kind Kind, std::vector<FunctionSummary::VFuncId> &VFuncIdList) {
9217 assert(Lex.getKind() == Kind);
9218 Lex.Lex();
9219
9220 if (parseToken(lltok::colon, "expected ':' here") ||
9221 parseToken(lltok::lparen, "expected '(' here"))
9222 return true;
9223
9224 IdToIndexMapType IdToIndexMap;
9225 do {
9226 FunctionSummary::VFuncId VFuncId;
9227 if (parseVFuncId(VFuncId, IdToIndexMap, VFuncIdList.size()))
9228 return true;
9229 VFuncIdList.push_back(VFuncId);
9230 } while (EatIfPresent(lltok::comma));
9231
9232 if (parseToken(lltok::rparen, "expected ')' here"))
9233 return true;
9234
9235 // Now that the VFuncIdList vector is finalized, it is safe to save the
9236 // locations of any forward GV references that need updating later.
9237 for (auto I : IdToIndexMap) {
9238 auto &Ids = ForwardRefTypeIds[I.first];
9239 for (auto P : I.second) {
9240 assert(VFuncIdList[P.first].GUID == 0 &&
9241 "Forward referenced type id GUID expected to be 0");
9242 Ids.emplace_back(&VFuncIdList[P.first].GUID, P.second);
9243 }
9244 }
9245
9246 return false;
9247}
9248
9249/// ConstVCallList
9250/// ::= Kind ':' '(' ConstVCall [',' ConstVCall]* ')'
9251bool LLParser::parseConstVCallList(
9252 lltok::Kind Kind,
9253 std::vector<FunctionSummary::ConstVCall> &ConstVCallList) {
9254 assert(Lex.getKind() == Kind);
9255 Lex.Lex();
9256
9257 if (parseToken(lltok::colon, "expected ':' here") ||
9258 parseToken(lltok::lparen, "expected '(' here"))
9259 return true;
9260
9261 IdToIndexMapType IdToIndexMap;
9262 do {
9263 FunctionSummary::ConstVCall ConstVCall;
9264 if (parseConstVCall(ConstVCall, IdToIndexMap, ConstVCallList.size()))
9265 return true;
9266 ConstVCallList.push_back(ConstVCall);
9267 } while (EatIfPresent(lltok::comma));
9268
9269 if (parseToken(lltok::rparen, "expected ')' here"))
9270 return true;
9271
9272 // Now that the ConstVCallList vector is finalized, it is safe to save the
9273 // locations of any forward GV references that need updating later.
9274 for (auto I : IdToIndexMap) {
9275 auto &Ids = ForwardRefTypeIds[I.first];
9276 for (auto P : I.second) {
9277 assert(ConstVCallList[P.first].VFunc.GUID == 0 &&
9278 "Forward referenced type id GUID expected to be 0");
9279 Ids.emplace_back(&ConstVCallList[P.first].VFunc.GUID, P.second);
9280 }
9281 }
9282
9283 return false;
9284}
9285
9286/// ConstVCall
9287/// ::= '(' VFuncId ',' Args ')'
9288bool LLParser::parseConstVCall(FunctionSummary::ConstVCall &ConstVCall,
9289 IdToIndexMapType &IdToIndexMap, unsigned Index) {
9290 if (parseToken(lltok::lparen, "expected '(' here") ||
9291 parseVFuncId(ConstVCall.VFunc, IdToIndexMap, Index))
9292 return true;
9293
9294 if (EatIfPresent(lltok::comma))
9295 if (parseArgs(ConstVCall.Args))
9296 return true;
9297
9298 if (parseToken(lltok::rparen, "expected ')' here"))
9299 return true;
9300
9301 return false;
9302}
9303
9304/// VFuncId
9305/// ::= 'vFuncId' ':' '(' (SummaryID | 'guid' ':' UInt64) ','
9306/// 'offset' ':' UInt64 ')'
9307bool LLParser::parseVFuncId(FunctionSummary::VFuncId &VFuncId,
9308 IdToIndexMapType &IdToIndexMap, unsigned Index) {
9309 assert(Lex.getKind() == lltok::kw_vFuncId);
9310 Lex.Lex();
9311
9312 if (parseToken(lltok::colon, "expected ':' here") ||
9313 parseToken(lltok::lparen, "expected '(' here"))
9314 return true;
9315
9316 if (Lex.getKind() == lltok::SummaryID) {
9317 VFuncId.GUID = 0;
9318 unsigned ID = Lex.getUIntVal();
9319 LocTy Loc = Lex.getLoc();
9320 // Keep track of the array index needing a forward reference.
9321 // We will save the location of the GUID needing an update, but
9322 // can only do so once the caller's std::vector is finalized.
9323 IdToIndexMap[ID].push_back(std::make_pair(Index, Loc));
9324 Lex.Lex();
9325 } else if (parseToken(lltok::kw_guid, "expected 'guid' here") ||
9326 parseToken(lltok::colon, "expected ':' here") ||
9327 parseUInt64(VFuncId.GUID))
9328 return true;
9329
9330 if (parseToken(lltok::comma, "expected ',' here") ||
9331 parseToken(lltok::kw_offset, "expected 'offset' here") ||
9332 parseToken(lltok::colon, "expected ':' here") ||
9333 parseUInt64(VFuncId.Offset) ||
9334 parseToken(lltok::rparen, "expected ')' here"))
9335 return true;
9336
9337 return false;
9338}
9339
9340/// GVFlags
9341/// ::= 'flags' ':' '(' 'linkage' ':' OptionalLinkageAux ','
9342/// 'notEligibleToImport' ':' Flag ',' 'live' ':' Flag ','
9343/// 'dsoLocal' ':' Flag ',' 'canAutoHide' ':' Flag ')'
9344bool LLParser::parseGVFlags(GlobalValueSummary::GVFlags &GVFlags) {
9345 assert(Lex.getKind() == lltok::kw_flags);
9346 Lex.Lex();
9347
9348 if (parseToken(lltok::colon, "expected ':' here") ||
9349 parseToken(lltok::lparen, "expected '(' here"))
9350 return true;
9351
9352 do {
9353 unsigned Flag = 0;
9354 switch (Lex.getKind()) {
9355 case lltok::kw_linkage:
9356 Lex.Lex();
9357 if (parseToken(lltok::colon, "expected ':'"))
9358 return true;
9359 bool HasLinkage;
9360 GVFlags.Linkage = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
9361 assert(HasLinkage && "Linkage not optional in summary entry");
9362 Lex.Lex();
9363 break;
9364 case lltok::kw_notEligibleToImport:
9365 Lex.Lex();
9366 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
9367 return true;
9368 GVFlags.NotEligibleToImport = Flag;
9369 break;
9370 case lltok::kw_live:
9371 Lex.Lex();
9372 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
9373 return true;
9374 GVFlags.Live = Flag;
9375 break;
9376 case lltok::kw_dsoLocal:
9377 Lex.Lex();
9378 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
9379 return true;
9380 GVFlags.DSOLocal = Flag;
9381 break;
9382 case lltok::kw_canAutoHide:
9383 Lex.Lex();
9384 if (parseToken(lltok::colon, "expected ':'") || parseFlag(Flag))
9385 return true;
9386 GVFlags.CanAutoHide = Flag;
9387 break;
9388 default:
9389 return error(Lex.getLoc(), "expected gv flag type");
9390 }
9391 } while (EatIfPresent(lltok::comma));
9392
9393 if (parseToken(lltok::rparen, "expected ')' here"))
9394 return true;
9395
9396 return false;
9397}
9398
9399/// GVarFlags
9400/// ::= 'varFlags' ':' '(' 'readonly' ':' Flag
9401/// ',' 'writeonly' ':' Flag
9402/// ',' 'constant' ':' Flag ')'
9403bool LLParser::parseGVarFlags(GlobalVarSummary::GVarFlags &GVarFlags) {
9404 assert(Lex.getKind() == lltok::kw_varFlags);
9405 Lex.Lex();
9406
9407 if (parseToken(lltok::colon, "expected ':' here") ||
9408 parseToken(lltok::lparen, "expected '(' here"))
9409 return true;
9410
9411 auto ParseRest = [this](unsigned int &Val) {
9412 Lex.Lex();
9413 if (parseToken(lltok::colon, "expected ':'"))
9414 return true;
9415 return parseFlag(Val);
9416 };
9417
9418 do {
9419 unsigned Flag = 0;
9420 switch (Lex.getKind()) {
9421 case lltok::kw_readonly:
9422 if (ParseRest(Flag))
9423 return true;
9424 GVarFlags.MaybeReadOnly = Flag;
9425 break;
9426 case lltok::kw_writeonly:
9427 if (ParseRest(Flag))
9428 return true;
9429 GVarFlags.MaybeWriteOnly = Flag;
9430 break;
9431 case lltok::kw_constant:
9432 if (ParseRest(Flag))
9433 return true;
9434 GVarFlags.Constant = Flag;
9435 break;
9436 case lltok::kw_vcall_visibility:
9437 if (ParseRest(Flag))
9438 return true;
9439 GVarFlags.VCallVisibility = Flag;
9440 break;
9441 default:
9442 return error(Lex.getLoc(), "expected gvar flag type");
9443 }
9444 } while (EatIfPresent(lltok::comma));
9445 return parseToken(lltok::rparen, "expected ')' here");
9446}
9447
9448/// ModuleReference
9449/// ::= 'module' ':' UInt
9450bool LLParser::parseModuleReference(StringRef &ModulePath) {
9451 // parse module id.
9452 if (parseToken(lltok::kw_module, "expected 'module' here") ||
9453 parseToken(lltok::colon, "expected ':' here") ||
9454 parseToken(lltok::SummaryID, "expected module ID"))
9455 return true;
9456
9457 unsigned ModuleID = Lex.getUIntVal();
9458 auto I = ModuleIdMap.find(ModuleID);
9459 // We should have already parsed all module IDs
9460 assert(I != ModuleIdMap.end());
9461 ModulePath = I->second;
9462 return false;
9463}
9464
9465/// GVReference
9466/// ::= SummaryID
9467bool LLParser::parseGVReference(ValueInfo &VI, unsigned &GVId) {
9468 bool WriteOnly = false, ReadOnly = EatIfPresent(lltok::kw_readonly);
9469 if (!ReadOnly)
9470 WriteOnly = EatIfPresent(lltok::kw_writeonly);
9471 if (parseToken(lltok::SummaryID, "expected GV ID"))
9472 return true;
9473
9474 GVId = Lex.getUIntVal();
9475 // Check if we already have a VI for this GV
9476 if (GVId < NumberedValueInfos.size()) {
9477 assert(NumberedValueInfos[GVId].getRef() != FwdVIRef);
9478 VI = NumberedValueInfos[GVId];
9479 } else
9480 // We will create a forward reference to the stored location.
9481 VI = ValueInfo(false, FwdVIRef);
9482
9483 if (ReadOnly)
9484 VI.setReadOnly();
9485 if (WriteOnly)
9486 VI.setWriteOnly();
9487 return false;
9488}
9489